@robinmordasiewicz/f5xc-xcsh 2.0.21-2601100343 → 2.0.21-2601101304

package/dist/index.js

@@ -7941,7 +7941,7 @@ var require_react_reconciler_development = __commonJS({
         var ContextConsumer = 9;
         var ContextProvider = 10;
         var ForwardRef = 11;
-        var Profiler = 12;
+        var Profiler2 = 12;
         var SuspenseComponent = 13;
         var MemoComponent = 14;
         var SimpleMemoComponent = 15;
@@ -8095,7 +8095,7 @@ var require_react_reconciler_development = __commonJS({
               return "Mode";
             case OffscreenComponent:
               return "Offscreen";
-            case Profiler:
+            case Profiler2:
               return "Profiler";
             case ScopeComponent:
               return "Scope";
@@ -14477,7 +14477,7 @@ var require_react_reconciler_development = __commonJS({
                   var root = parentFiber.stateNode;
                   root.effectDuration += elapsedTime;
                   return;
-                case Profiler:
+                case Profiler2:
                   var parentStateNode = parentFiber.stateNode;
                   parentStateNode.effectDuration += elapsedTime;
                   return;
@@ -14499,7 +14499,7 @@ var require_react_reconciler_development = __commonJS({
                     root.passiveEffectDuration += elapsedTime;
                   }
                   return;
-                case Profiler:
+                case Profiler2:
                   var parentStateNode = parentFiber.stateNode;
                   if (parentStateNode !== null) {
                     parentStateNode.passiveEffectDuration += elapsedTime;
@@ -16964,7 +16964,7 @@ var require_react_reconciler_development = __commonJS({
               pushProvider(workInProgress2, context, newValue);
               break;
             }
-            case Profiler:
+            case Profiler2:
               {
                 var hasChildWork = includesSomeLane(renderLanes2, workInProgress2.childLanes);
                 if (hasChildWork) {
@@ -17108,7 +17108,7 @@ var require_react_reconciler_development = __commonJS({
               return updateFragment(current2, workInProgress2, renderLanes2);
             case Mode:
               return updateMode(current2, workInProgress2, renderLanes2);
-            case Profiler:
+            case Profiler2:
               return updateProfiler(current2, workInProgress2, renderLanes2);
             case ContextProvider:
               return updateContextProvider(current2, workInProgress2, renderLanes2);
@@ -17543,7 +17543,7 @@ var require_react_reconciler_development = __commonJS({
             case ForwardRef:
             case Fragment2:
             case Mode:
-            case Profiler:
+            case Profiler2:
             case ContextConsumer:
             case MemoComponent:
               bubbleProperties(workInProgress2);
@@ -18383,7 +18383,7 @@ var require_react_reconciler_development = __commonJS({
           {
             if ((finishedWork.flags & Update) !== NoFlags) {
               switch (finishedWork.tag) {
-                case Profiler: {
+                case Profiler2: {
                   var passiveEffectDuration = finishedWork.stateNode.passiveEffectDuration;
                   var _finishedWork$memoize = finishedWork.memoizedProps, id = _finishedWork$memoize.id, onPostCommit = _finishedWork$memoize.onPostCommit;
                   var commitTime2 = getCommitTime();
@@ -18403,7 +18403,7 @@ var require_react_reconciler_development = __commonJS({
                         var root = parentFiber.stateNode;
                         root.passiveEffectDuration += passiveEffectDuration;
                         break outer;
-                      case Profiler:
+                      case Profiler2:
                         var parentStateNode = parentFiber.stateNode;
                         parentStateNode.passiveEffectDuration += passiveEffectDuration;
                         break outer;
@@ -18536,7 +18536,7 @@ var require_react_reconciler_development = __commonJS({
               case HostPortal: {
                 break;
               }
-              case Profiler: {
+              case Profiler2: {
                 {
                   var _finishedWork$memoize2 = finishedWork.memoizedProps, onCommit = _finishedWork$memoize2.onCommit, onRender = _finishedWork$memoize2.onRender;
                   var effectDuration = finishedWork.stateNode.effectDuration;
@@ -18562,7 +18562,7 @@ var require_react_reconciler_development = __commonJS({
                           var root = parentFiber.stateNode;
                           root.effectDuration += effectDuration;
                           break outer;
-                        case Profiler:
+                        case Profiler2:
                           var parentStateNode = parentFiber.stateNode;
                           parentStateNode.effectDuration += effectDuration;
                           break outer;
@@ -22319,7 +22319,7 @@ var require_react_reconciler_development = __commonJS({
               error('Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.', typeof pendingProps.id);
             }
           }
-          var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
+          var fiber = createFiber(Profiler2, pendingProps, key, mode | ProfileMode);
           fiber.elementType = REACT_PROFILER_TYPE;
           fiber.lanes = lanes;
           {
@@ -40058,6 +40058,582 @@ var require_cli_spinners = __commonJS({
   }
 });
 
+// src/profiling/profiler.ts
+var DEFAULT_THRESHOLDS = {
+  slowPhaseMs: 100,
+  slowNetworkMs: 500,
+  memorySpikeMB: 50
+};
+function getProfileLevel() {
+  const level = process.env.XCSH_PROFILE_LEVEL;
+  if (level === "basic" || level === "detailed" || level === "full") {
+    return level;
+  }
+  if (process.env.XCSH_PROFILE === "true") {
+    return "basic";
+  }
+  return "none";
+}
+var Profiler = class {
+  config;
+  spans = /* @__PURE__ */ new Map();
+  networkSpans = /* @__PURE__ */ new Map();
+  memorySnapshots = [];
+  startTime;
+  spanCounter = 0;
+  rootSpanId = null;
+  constructor(config) {
+    const level = getProfileLevel();
+    this.config = {
+      enabled: level !== "none",
+      level,
+      thresholds: {
+        ...DEFAULT_THRESHOLDS,
+        ...config?.thresholds
+      }
+    };
+    this.startTime = Date.now();
+    if (this.isEnabled()) {
+      this.memorySnapshot("profiler_init");
+    }
+  }
+  /**
+   * Check if profiling is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Get current profiling level
+   */
+  getLevel() {
+    return this.config.level;
+  }
+  /**
+   * Get elapsed time since profiler start
+   */
+  elapsed() {
+    return Date.now() - this.startTime;
+  }
+  /**
+   * Generate unique span ID
+   */
+  generateSpanId() {
+    return `span_${++this.spanCounter}`;
+  }
+  /**
+   * Start a new profiling span
+   */
+  startSpan(name, label, parentId) {
+    if (!this.isEnabled()) return "";
+    const id = this.generateSpanId();
+    const span = {
+      id,
+      name,
+      label: label ?? name,
+      parentId: parentId ?? void 0,
+      startTime: this.elapsed(),
+      endTime: void 0,
+      duration: void 0,
+      metadata: {},
+      isNetwork: void 0,
+      children: []
+    };
+    this.spans.set(id, span);
+    if (!parentId && !this.rootSpanId) {
+      this.rootSpanId = id;
+    }
+    if (parentId) {
+      const parent = this.spans.get(parentId);
+      if (parent) {
+        parent.children.push(span);
+      }
+    }
+    if (this.config.level === "basic") {
+      console.error(`[PROFILE] ${name}:start: ${span.startTime}ms`);
+    }
+    return id;
+  }
+  /**
+   * End a profiling span
+   */
+  endSpan(spanId, metadata) {
+    if (!this.isEnabled() || !spanId) return;
+    const span = this.spans.get(spanId);
+    if (!span) return;
+    span.endTime = this.elapsed();
+    span.duration = span.endTime - span.startTime;
+    if (metadata) {
+      span.metadata = { ...span.metadata, ...metadata };
+    }
+    if (this.config.level === "basic") {
+      console.error(
+        `[PROFILE] ${span.name}:end: ${span.endTime}ms (${span.duration}ms)`
+      );
+    }
+  }
+  /**
+   * Create a checkpoint within current context (simple timing marker)
+   */
+  checkpoint(name) {
+    if (!this.isEnabled()) return;
+    const elapsed = this.elapsed();
+    if (this.config.level === "basic") {
+      console.error(`[PROFILE] ${name}: ${elapsed}ms`);
+    }
+  }
+  /**
+   * Start a network span with additional request details
+   */
+  startNetworkSpan(url, method, parentId) {
+    if (!this.isEnabled()) return "";
+    const id = this.generateSpanId();
+    const span = {
+      id,
+      name: `network:${method}`,
+      label: `${method} ${this.truncateUrl(url)}`,
+      parentId: parentId ?? void 0,
+      startTime: this.elapsed(),
+      endTime: void 0,
+      duration: void 0,
+      metadata: {},
+      children: [],
+      isNetwork: true,
+      url,
+      method,
+      statusCode: void 0,
+      requestSize: void 0,
+      responseSize: void 0,
+      retryCount: 0,
+      error: void 0
+    };
+    this.networkSpans.set(id, span);
+    this.spans.set(id, span);
+    if (parentId) {
+      const parent = this.spans.get(parentId);
+      if (parent) {
+        parent.children.push(span);
+      }
+    }
+    if (this.config.level !== "none") {
+      console.error(
+        `[PROFILE] network:${method}:start: ${span.startTime}ms - ${this.truncateUrl(url)}`
+      );
+    }
+    return id;
+  }
+  /**
+   * End a network span with response details
+   */
+  endNetworkSpan(spanId, details) {
+    if (!this.isEnabled() || !spanId) return;
+    const span = this.networkSpans.get(spanId);
+    if (!span) return;
+    span.endTime = this.elapsed();
+    span.duration = span.endTime - span.startTime;
+    span.statusCode = details.statusCode;
+    span.responseSize = details.responseSize;
+    span.retryCount = details.retryCount ?? 0;
+    span.error = details.error;
+    if (this.config.level !== "none") {
+      const status = details.error ? `ERROR: ${details.error}` : `${details.statusCode ?? "?"}`;
+      console.error(
+        `[PROFILE] network:end: ${span.endTime}ms (${span.duration}ms) - ${status}`
+      );
+    }
+  }
+  /**
+   * Take a memory snapshot
+   */
+  memorySnapshot(label) {
+    if (!this.isEnabled()) return;
+    if (this.config.level === "basic") return;
+    const memory = process.memoryUsage();
+    const snapshot = {
+      timestamp: this.elapsed(),
+      label,
+      heapUsedMB: Math.round(memory.heapUsed / 1024 / 1024 * 100) / 100,
+      heapTotalMB: Math.round(memory.heapTotal / 1024 / 1024 * 100) / 100,
+      externalMB: Math.round(memory.external / 1024 / 1024 * 100) / 100,
+      rssMB: Math.round(memory.rss / 1024 / 1024 * 100) / 100
+    };
+    this.memorySnapshots.push(snapshot);
+    if (this.config.level === "detailed" || this.config.level === "full") {
+      console.error(
+        `[PROFILE] memory:${label}: heap=${snapshot.heapUsedMB}MB rss=${snapshot.rssMB}MB`
+      );
+    }
+  }
+  /**
+   * Identify bottlenecks based on configured thresholds
+   */
+  identifyBottlenecks() {
+    const bottlenecks = [];
+    for (const span of this.spans.values()) {
+      if (!span.duration) continue;
+      const isNetwork = this.networkSpans.has(span.id);
+      const threshold = isNetwork ? this.config.thresholds.slowNetworkMs : this.config.thresholds.slowPhaseMs;
+      if (span.duration > threshold) {
+        const suggestion = isNetwork ? "Check network connectivity or API server status" : "Consider lazy loading or parallelizing this operation";
+        bottlenecks.push({
+          spanId: span.id,
+          spanName: span.name,
+          duration: span.duration,
+          threshold,
+          reason: `Duration ${span.duration}ms exceeds threshold ${threshold}ms`,
+          suggestion
+        });
+      }
+    }
+    if (this.memorySnapshots.length >= 2) {
+      const first = this.memorySnapshots[0];
+      const peak = Math.max(...this.memorySnapshots.map((s) => s.rssMB));
+      const spike = peak - (first?.rssMB ?? 0);
+      if (spike > this.config.thresholds.memorySpikeMB) {
+        bottlenecks.push({
+          spanId: "memory",
+          spanName: "memory_spike",
+          duration: spike,
+          threshold: this.config.thresholds.memorySpikeMB,
+          reason: `Memory increased by ${spike.toFixed(1)}MB`,
+          suggestion: "Review large object allocations during startup"
+        });
+      }
+    }
+    return bottlenecks.sort((a, b) => b.duration - a.duration);
+  }
+  /**
+   * Get all root-level spans (no parent)
+   */
+  getRootSpans() {
+    return Array.from(this.spans.values()).filter((span) => !span.parentId);
+  }
+  /**
+   * Generate complete profile report
+   */
+  generateReport() {
+    const spans = this.getRootSpans();
+    const networkSpans = Array.from(this.networkSpans.values());
+    const bottlenecks = this.identifyBottlenecks();
+    const memoryStart = this.memorySnapshots[0]?.rssMB ?? 0;
+    const memoryEnd = this.memorySnapshots[this.memorySnapshots.length - 1]?.rssMB ?? 0;
+    const memoryPeak = Math.max(
+      ...this.memorySnapshots.map((s) => s.rssMB),
+      0
+    );
+    return {
+      startupTimeMs: this.elapsed(),
+      spans,
+      networkSpans,
+      memorySnapshots: this.memorySnapshots,
+      memoryPeakMB: memoryPeak,
+      memoryDeltaMB: memoryEnd - memoryStart,
+      bottlenecks,
+      level: this.config.level
+    };
+  }
+  /**
+   * Truncate URL for display
+   */
+  truncateUrl(url) {
+    try {
+      const parsed = new URL(url);
+      return parsed.pathname.slice(0, 40) + (parsed.pathname.length > 40 ? "..." : "");
+    } catch {
+      return url.slice(0, 40);
+    }
+  }
+};
+var globalProfiler = null;
+function getProfiler() {
+  if (!globalProfiler) {
+    globalProfiler = new Profiler();
+  }
+  return globalProfiler;
+}
+function initProfiler(config) {
+  globalProfiler = new Profiler(config);
+  return globalProfiler;
+}
+
+// src/profiling/reporter.ts
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function formatSpanText(span, indent = 0, totalTime) {
+  const lines = [];
+  const prefix = "  ".repeat(indent);
+  const duration = span.duration ?? 0;
+  const percentage = totalTime > 0 ? (duration / totalTime * 100).toFixed(1) : "0";
+  const networkTag = span.isNetwork ? " [N]" : "";
+  const warning = duration > 500 ? " !!" : duration > 100 ? " !" : "";
+  lines.push(
+    `${prefix}${span.label}${networkTag}: ${formatDuration(duration)} (${percentage}%)${warning}`
+  );
+  if (Object.keys(span.metadata).length > 0) {
+    const metaStr = Object.entries(span.metadata).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+    lines.push(`${prefix}  metadata: ${metaStr}`);
+  }
+  for (const child of span.children) {
+    lines.push(...formatSpanText(child, indent + 1, totalTime));
+  }
+  return lines;
+}
+function formatBottlenecksText(bottlenecks) {
+  if (bottlenecks.length === 0) {
+    return ["  No bottlenecks detected"];
+  }
+  const lines = [];
+  for (let i = 0; i < bottlenecks.length; i++) {
+    const b = bottlenecks[i];
+    if (!b) continue;
+    lines.push(`  ${i + 1}. ${b.spanName}: ${formatDuration(b.duration)}`);
+    lines.push(`     Threshold: ${formatDuration(b.threshold)}`);
+    lines.push(`     Suggestion: ${b.suggestion}`);
+  }
+  return lines;
+}
+function formatMemoryText(snapshots) {
+  if (snapshots.length === 0) {
+    return ["  No memory snapshots"];
+  }
+  const first = snapshots[0];
+  const last = snapshots[snapshots.length - 1];
+  const peak = Math.max(...snapshots.map((s) => s.rssMB));
+  const lines = [];
+  lines.push(
+    `  Start: ${first?.rssMB.toFixed(1)}MB -> Peak: ${peak.toFixed(1)}MB -> End: ${last?.rssMB.toFixed(1)}MB`
+  );
+  lines.push(
+    `  Delta: ${((last?.rssMB ?? 0) - (first?.rssMB ?? 0)).toFixed(1)}MB`
+  );
+  return lines;
+}
+function formatReportText(report) {
+  const lines = [];
+  lines.push("=".repeat(60));
+  lines.push(`XCSH Startup Profile Report`);
+  lines.push(`Total Time: ${formatDuration(report.startupTimeMs)}`);
+  lines.push(`Profile Level: ${report.level}`);
+  lines.push("=".repeat(60));
+  lines.push("");
+  lines.push("PHASES:");
+  lines.push("-".repeat(40));
+  for (const span of report.spans) {
+    lines.push(...formatSpanText(span, 0, report.startupTimeMs));
+  }
+  if (report.networkSpans.length > 0) {
+    lines.push("");
+    lines.push("NETWORK CALLS:");
+    lines.push("-".repeat(40));
+    for (const span of report.networkSpans) {
+      const status = span.error ? `ERROR: ${span.error}` : `${span.statusCode ?? "?"}`;
+      const retries = span.retryCount > 0 ? ` (${span.retryCount} retries)` : "";
+      lines.push(
+        `  ${span.method} ${span.url.slice(0, 50)}: ${formatDuration(span.duration ?? 0)} - ${status}${retries}`
+      );
+    }
+  }
+  if (report.memorySnapshots.length > 0) {
+    lines.push("");
+    lines.push("MEMORY:");
+    lines.push("-".repeat(40));
+    lines.push(...formatMemoryText(report.memorySnapshots));
+  }
+  if (report.bottlenecks.length > 0) {
+    lines.push("");
+    lines.push("BOTTLENECKS:");
+    lines.push("-".repeat(40));
+    lines.push(...formatBottlenecksText(report.bottlenecks));
+  }
+  lines.push("");
+  lines.push("=".repeat(60));
+  lines.push(
+    "[N] = Network call  !! = Critical (>500ms)  ! = Warning (>100ms)"
+  );
+  lines.push("=".repeat(60));
+  return lines.join("\n");
+}
+
+// src/profiling/waterfall.ts
+var BOX_CHARS = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  cross: "\u253C",
+  teeDown: "\u252C",
+  teeUp: "\u2534",
+  teeRight: "\u251C",
+  teeLeft: "\u2524"
+};
+var TREE_CHARS = {
+  branch: "\u251C",
+  last: "\u2514",
+  vertical: "\u2502",
+  horizontal: "\u2500"
+};
+function flattenSpans(spans, depth = 0, bottleneckIds) {
+  const result = [];
+  for (let i = 0; i < spans.length; i++) {
+    const span = spans[i];
+    if (!span) continue;
+    const isLast = i === spans.length - 1;
+    result.push({
+      name: span.name,
+      label: span.label,
+      startTime: span.startTime,
+      duration: span.duration ?? 0,
+      depth,
+      isNetwork: span.isNetwork ?? false,
+      isBottleneck: bottleneckIds.has(span.id),
+      isLast
+    });
+    if (span.children.length > 0) {
+      result.push(
+        ...flattenSpans(span.children, depth + 1, bottleneckIds)
+      );
+    }
+  }
+  return result;
+}
+function createTreePrefix(depth, isLast) {
+  if (depth === 0) return "";
+  const indent = "  ".repeat(depth - 1);
+  const branch = isLast ? TREE_CHARS.last : TREE_CHARS.branch;
+  return indent + branch + TREE_CHARS.horizontal;
+}
+function renderBar(startTime, duration, totalTime, barWidth) {
+  if (totalTime === 0) return " ".repeat(barWidth);
+  const startPos = Math.floor(startTime / totalTime * barWidth);
+  const barLen = Math.max(1, Math.ceil(duration / totalTime * barWidth));
+  const before = " ".repeat(Math.min(startPos, barWidth));
+  const bar = "\u2588".repeat(Math.min(barLen, barWidth - startPos));
+  const after = " ".repeat(Math.max(0, barWidth - startPos - barLen));
+  return (before + bar + after).slice(0, barWidth);
+}
+function formatDuration2(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function renderWaterfall(report) {
+  const lines = [];
+  const totalTime = report.startupTimeMs;
+  const labelWidth = 28;
+  const barWidth = 35;
+  const timeWidth = 10;
+  const totalWidth = labelWidth + barWidth + timeWidth + 6;
+  const bottleneckIds = new Set(report.bottlenecks.map((b) => b.spanId));
+  const flatSpans = flattenSpans(report.spans, 0, bottleneckIds);
+  lines.push(
+    BOX_CHARS.topLeft + BOX_CHARS.horizontal.repeat(totalWidth - 2) + BOX_CHARS.topRight
+  );
+  lines.push(
+    BOX_CHARS.vertical + ` XCSH Startup Profile`.padEnd(totalWidth - 14) + `Total: ${formatDuration2(totalTime)}`.padStart(12) + BOX_CHARS.vertical
+  );
+  lines.push(
+    BOX_CHARS.teeRight + BOX_CHARS.horizontal.repeat(totalWidth - 2) + BOX_CHARS.teeLeft
+  );
+  const headerPhase = "Phase".padEnd(labelWidth);
+  const headerTimeline = "Timeline".padEnd(barWidth);
+  const headerTime = "Time".padStart(timeWidth);
+  lines.push(
+    BOX_CHARS.vertical + ` ${headerPhase}${BOX_CHARS.vertical} ${headerTimeline}${BOX_CHARS.vertical}${headerTime} ` + BOX_CHARS.vertical
+  );
+  lines.push(
+    BOX_CHARS.teeRight + BOX_CHARS.horizontal.repeat(labelWidth + 1) + BOX_CHARS.cross + BOX_CHARS.horizontal.repeat(barWidth + 1) + BOX_CHARS.cross + BOX_CHARS.horizontal.repeat(timeWidth + 1) + BOX_CHARS.teeLeft
+  );
+  for (const span of flatSpans) {
+    const prefix = createTreePrefix(span.depth, span.isLast);
+    const networkTag = span.isNetwork ? " [N]" : "";
+    const label = (prefix + span.label + networkTag).slice(0, labelWidth).padEnd(labelWidth);
+    const bar = renderBar(
+      span.startTime,
+      span.duration,
+      totalTime,
+      barWidth
+    );
+    const time = formatDuration2(span.duration).padStart(timeWidth - 2);
+    const warning = span.isBottleneck ? " !!" : span.duration > 100 ? "  !" : "   ";
+    lines.push(
+      BOX_CHARS.vertical + ` ${label}${BOX_CHARS.vertical} ${bar}${BOX_CHARS.vertical}${time}${warning}` + BOX_CHARS.vertical
+    );
+  }
+  lines.push(
+    BOX_CHARS.bottomLeft + BOX_CHARS.horizontal.repeat(totalWidth - 2) + BOX_CHARS.bottomRight
+  );
+  lines.push(
+    "[N] = Network call  !! = Bottleneck (>500ms)  ! = Slow (>100ms)"
+  );
+  if (report.memorySnapshots.length > 0) {
+    const first = report.memorySnapshots[0];
+    const last = report.memorySnapshots[report.memorySnapshots.length - 1];
+    lines.push("");
+    lines.push(
+      `Memory: ${first?.rssMB.toFixed(1)}MB -> Peak ${report.memoryPeakMB.toFixed(1)}MB -> ${last?.rssMB.toFixed(1)}MB (${report.memoryDeltaMB >= 0 ? "+" : ""}${report.memoryDeltaMB.toFixed(1)}MB)`
+    );
+  }
+  if (report.bottlenecks.length > 0) {
+    lines.push("");
+    lines.push("Bottlenecks Identified:");
+    for (let i = 0; i < Math.min(report.bottlenecks.length, 3); i++) {
+      const b = report.bottlenecks[i];
+      if (!b) continue;
+      lines.push(
+        `  ${i + 1}. ${b.spanName}: ${formatDuration2(b.duration)} - ${b.suggestion}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function renderCompactWaterfall(report) {
+  const lines = [];
+  const totalTime = report.startupTimeMs;
+  lines.push(`
+[PROFILE] Startup: ${formatDuration2(totalTime)}`);
+  for (const span of report.spans) {
+    const duration = span.duration ?? 0;
+    const percentage = (duration / totalTime * 100).toFixed(0);
+    const bar = "\u2588".repeat(
+      Math.min(20, Math.ceil(duration / totalTime * 20))
+    );
+    lines.push(
+      `  ${span.label.padEnd(20)} ${bar.padEnd(20)} ${formatDuration2(duration).padStart(8)} (${percentage}%)`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/profiling/index.ts
+function printProfileReport() {
+  const profiler2 = getProfiler();
+  if (!profiler2.isEnabled()) return;
+  const report = profiler2.generateReport();
+  const level = profiler2.getLevel();
+  let output;
+  switch (level) {
+    case "full":
+      output = renderWaterfall(report);
+      break;
+    case "detailed":
+      output = formatReportText(report);
+      break;
+    case "basic":
+      output = renderCompactWaterfall(report);
+      break;
+    default:
+      return;
+  }
+  console.error("\n" + output);
+}
+
 // node_modules/ink/build/render.js
 import { Stream } from "stream";
 import process12 from "process";
@@ -48639,8 +49215,8 @@ function getLogoModeFromEnv(envPrefix) {
 var CLI_NAME = "xcsh";
 var CLI_FULL_NAME = "F5 Distributed Cloud Shell";
 function getVersion() {
-  if ("v2.0.21-2601100343") {
-    return "v2.0.21-2601100343";
+  if ("v2.0.21-2601101304") {
+    return "v2.0.21-2601101304";
   }
   if (process.env.XCSH_VERSION) {
     return process.env.XCSH_VERSION;
@@ -49040,6 +49616,9 @@ var DEFAULT_RETRY_CONFIG = {
   backoffMultiplier: 2,
   jitter: true
 };
+var STARTUP_TIMEOUT = 3e3;
+var STARTUP_MAX_RETRIES = 0;
+var CONNECTIVITY_TIMEOUT = 2e3;
 var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([
   408,
   // Request Timeout
@@ -49095,18 +49674,33 @@ var APIClient = class {
   /**
    * Validate the API token by making a lightweight API call.
    * Returns true if token is valid, false otherwise.
+   *
+   * @param options.startupMode - Use aggressive timeouts for fast-fail during startup
    */
-  async validateToken() {
+  async validateToken(options) {
+    const startupMode = options?.startupMode ?? false;
     if (!this.apiToken) {
       this._isValidated = false;
       this._validationError = "No API token configured";
       return { valid: false, error: this._validationError };
     }
     if (this.debug) {
-      console.error(`DEBUG: Validating token against ${this.serverUrl}`);
+      console.error(
+        `DEBUG: Validating token against ${this.serverUrl}${startupMode ? " (startup mode)" : ""}`
+      );
     }
     try {
-      await this.get("/api/web/namespaces");
+      const requestOptions = {
+        method: "GET",
+        path: "/api/web/namespaces"
+      };
+      if (startupMode) {
+        requestOptions.timeout = STARTUP_TIMEOUT;
+      }
+      await this.requestWithOptions(
+        requestOptions,
+        startupMode ? { maxRetries: STARTUP_MAX_RETRIES } : void 0
+      );
       this._isValidated = true;
       this._validationError = null;
       return { valid: true };
@@ -49120,6 +49714,20 @@ var APIClient = class {
           this._isValidated = false;
           this._validationError = "Token lacks required permissions";
           return { valid: false, error: this._validationError };
+        } else if (error.statusCode === 408 || error.statusCode === 0) {
+          if (startupMode) {
+            this._isValidated = false;
+            this._validationError = "API endpoint unreachable - request timed out";
+            return { valid: false, error: this._validationError };
+          }
+          if (this.debug) {
+            console.error(
+              `DEBUG: Validation timed out, assuming token is valid`
+            );
+          }
+          this._isValidated = true;
+          this._validationError = null;
+          return { valid: true };
         } else {
           if (this.debug) {
             console.error(
@@ -49131,6 +49739,11 @@ var APIClient = class {
           return { valid: true };
         }
       } else {
+        if (startupMode) {
+          this._isValidated = false;
+          this._validationError = `API endpoint unreachable - ${error instanceof Error ? error.message : "Unknown error"}`;
+          return { valid: false, error: this._validationError };
+        }
         if (this.debug) {
           console.error(
             `DEBUG: Validation error: ${error instanceof Error ? error.message : "Unknown"}, assuming token is valid`
@@ -49167,6 +49780,30 @@ var APIClient = class {
   getServerUrl() {
     return this.serverUrl;
   }
+  /**
+   * Check connectivity to the API server.
+   * Uses a lightweight HEAD request with aggressive timeout for fast-fail.
+   * This is used during startup to quickly detect if API is unreachable.
+   */
+  async checkConnectivity() {
+    const start = Date.now();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      CONNECTIVITY_TIMEOUT
+    );
+    try {
+      await fetch(this.serverUrl, {
+        method: "HEAD",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return { reachable: true, latencyMs: Date.now() - start };
+    } catch {
+      clearTimeout(timeoutId);
+      return { reachable: false };
+    }
+  }
   /**
    * Build full URL from path and query parameters
    */
@@ -49271,11 +49908,25 @@ var APIClient = class {
       throw error;
     }
   }
+  /**
+   * Execute an HTTP request with retry logic and optional retry override
+   */
+  async requestWithOptions(options, retryOverride) {
+    return this.requestInternal(options, retryOverride);
+  }
   /**
    * Execute an HTTP request with retry logic
    */
   async request(options) {
+    return this.requestInternal(options);
+  }
+  /**
+   * Internal request implementation with optional retry override
+   */
+  async requestInternal(options, retryOverride) {
     const url = this.buildUrl(options.path, options.query);
+    const profiler2 = getProfiler();
+    const networkSpan = profiler2.startNetworkSpan(url, options.method);
     const headers = {
       "Content-Type": "application/json",
       Accept: "application/json",
@@ -49292,19 +49943,28 @@ var APIClient = class {
       }
     }
     let lastError;
-    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+    let retryCount = 0;
+    const maxRetries = retryOverride?.maxRetries ?? this.retryConfig.maxRetries;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
       try {
-        return await this.executeRequest(
+        const result = await this.executeRequest(
           options,
           url,
           headers,
           body
         );
+        profiler2.endNetworkSpan(networkSpan, {
+          statusCode: result.statusCode,
+          responseSize: JSON.stringify(result.data).length,
+          retryCount
+        });
+        return result;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         const isRetryable = this.isRetryableError(error);
-        const hasRetriesLeft = attempt < this.retryConfig.maxRetries;
+        const hasRetriesLeft = attempt < maxRetries;
         if (isRetryable && hasRetriesLeft) {
+          retryCount++;
           const delay = calculateBackoffDelay(
             attempt,
             this.retryConfig
@@ -49312,12 +49972,17 @@ var APIClient = class {
           if (this.debug) {
             const statusInfo = error instanceof APIError ? ` (${error.statusCode})` : "";
             console.error(
-              `DEBUG: Request failed${statusInfo}, retrying in ${delay}ms (attempt ${attempt + 1}/${this.retryConfig.maxRetries})`
+              `DEBUG: Request failed${statusInfo}, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`
             );
           }
           await sleep(delay);
           continue;
         }
+        profiler2.endNetworkSpan(networkSpan, {
+          statusCode: error instanceof APIError ? error.statusCode : 0,
+          retryCount,
+          error: lastError.message
+        });
         throw error;
       }
     }
@@ -75275,6 +75940,8 @@ var REPLSession = class {
   // Fallback tracking for improved error messages
   _fallbackAttempted = false;
   _fallbackReason = null;
+  // Connection status for graceful offline handling
+  _connectionStatus = "unknown";
   constructor(config = {}) {
     this._namespace = config.namespace ?? this.getDefaultNamespace();
     this._contextPath = new ContextPath();
@@ -75304,48 +75971,91 @@ var REPLSession = class {
   }
   /**
    * Initialize the session (async operations)
+   * Uses fast-fail connectivity check to avoid long waits when API is unreachable.
    */
   async initialize() {
-    const startTime = Date.now();
-    const profile = (label) => {
-      if (this._debug || process.env.XCSH_PROFILE === "true") {
-        console.error(
-          `[PROFILE] ${label}: ${Date.now() - startTime}ms`
-        );
-      }
-    };
-    profile("initialize:start");
+    const profiler2 = getProfiler();
+    const historySpan = profiler2.startSpan(
+      "history_load",
+      "History Loading"
+    );
     try {
       this._history = await HistoryManager.create(
         getHistoryFilePath(),
         1e3
       );
-      profile("history:loaded");
+      profiler2.endSpan(historySpan, { status: "loaded" });
     } catch (error) {
       console.error("Warning: could not initialize history:", error);
       this._history = new HistoryManager(getHistoryFilePath(), 1e3);
-      profile("history:fallback");
+      profiler2.endSpan(historySpan, {
+        status: "fallback",
+        error: String(error)
+      });
     }
+    const profileSpan = profiler2.startSpan(
+      "profile_load",
+      "Profile Loading"
+    );
     await this.loadActiveProfile();
-    profile("profile:loaded");
+    profiler2.endSpan(profileSpan, { profileName: this._activeProfileName });
     if (this._apiClient?.isAuthenticated()) {
-      profile("token_validation:start");
+      const connectivitySpan = profiler2.startSpan(
+        "connectivity_check",
+        "Connectivity Check"
+      );
+      const connectivity = await this._apiClient.checkConnectivity();
+      profiler2.endSpan(connectivitySpan, {
+        reachable: connectivity.reachable,
+        latencyMs: connectivity.latencyMs
+      });
+      if (!connectivity.reachable) {
+        this._connectionStatus = "offline";
+        this._validationError = "API endpoint unreachable - running in offline mode";
+        debugProtocol.auth("connectivity_failed", {
+          serverUrl: this._serverUrl,
+          status: "offline"
+        });
+        return;
+      }
+      const tokenSpan = profiler2.startSpan(
+        "token_validation",
+        "Token Validation"
+      );
       debugProtocol.auth("token_validation_start", {
         serverUrl: this._serverUrl,
         hasApiClient: true,
-        authSource: this._authSource
+        authSource: this._authSource,
+        startupMode: true
+      });
+      const result = await this._apiClient.validateToken({
+        startupMode: true
       });
-      const result = await this._apiClient.validateToken();
       this._tokenValidated = result.valid;
       this._validationError = result.error ?? null;
-      profile("token_validation:complete");
+      if (result.valid) {
+        this._connectionStatus = "connected";
+      } else if (result.error?.includes("unreachable") || result.error?.includes("timed out")) {
+        this._connectionStatus = "offline";
+      } else {
+        this._connectionStatus = "error";
+      }
+      profiler2.endSpan(tokenSpan, {
+        valid: result.valid,
+        error: result.error,
+        connectionStatus: this._connectionStatus
+      });
       debugProtocol.auth("token_validation_complete", {
         valid: result.valid,
         error: result.error,
         tokenValidated: this._tokenValidated,
         validationError: this._validationError,
-        authSource: this._authSource
+        authSource: this._authSource,
+        connectionStatus: this._connectionStatus
       });
+      if (this._connectionStatus === "offline") {
+        return;
+      }
       if (!result.valid && (this._authSource === "env" || this._authSource === "mixed")) {
         if (this._activeProfile?.apiToken && this._activeProfile.apiToken !== this._apiToken) {
           this._fallbackAttempted = true;
@@ -75366,20 +76076,29 @@ var REPLSession = class {
             apiToken: this._apiToken,
             debug: this._debug
           });
-          profile("fallback_validation:start");
-          const fallbackResult = await this._apiClient.validateToken();
-          profile("fallback_validation:complete");
+          const fallbackSpan = profiler2.startSpan(
+            "fallback_validation",
+            "Fallback Token Validation"
+          );
+          const fallbackResult = await this._apiClient.validateToken({
+            startupMode: true
+          });
+          profiler2.endSpan(fallbackSpan, {
+            valid: fallbackResult.valid
+          });
           if (fallbackResult.valid) {
             this._tokenValidated = true;
             this._validationError = null;
             this._authSource = "profile-fallback";
             this._fallbackReason = null;
+            this._connectionStatus = "connected";
             debugProtocol.auth("token_fallback_success", {
               authSource: this._authSource,
               profileName: this._activeProfileName
             });
           } else {
             this._fallbackReason = `Profile '${this._activeProfileName}' credentials are also invalid`;
+            this._connectionStatus = "error";
             debugProtocol.auth("token_fallback_failed", {
               error: fallbackResult.error,
               profileName: this._activeProfileName
@@ -75403,13 +76122,15 @@ var REPLSession = class {
           });
         }
       }
-      if (this._tokenValidated) {
-        profile("user_info:start");
+      if (this._tokenValidated && this._connectionStatus === "connected") {
+        const userInfoSpan = profiler2.startSpan(
+          "user_info",
+          "User Info Fetch"
+        );
         await this.fetchUserInfo();
-        profile("user_info:complete");
+        profiler2.endSpan(userInfoSpan, { username: this._username });
       }
     }
-    profile("initialize:complete");
   }
   /**
    * Fetch user info from the API
@@ -75613,6 +76334,18 @@ var REPLSession = class {
   getFallbackReason() {
     return this._fallbackReason;
   }
+  /**
+   * Get the current connection status
+   */
+  getConnectionStatus() {
+    return this._connectionStatus;
+  }
+  /**
+   * Check if running in offline mode (API unreachable)
+   */
+  isOfflineMode() {
+    return this._connectionStatus === "offline";
+  }
   /**
    * Get the API client
    */
@@ -85491,29 +86224,26 @@ var HeadlessController = class {
 
 // src/index.tsx
 var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
-var _startupTime = Date.now();
-var _profile = (label) => {
-  if (process.env.XCSH_PROFILE === "true") {
-    console.error(`[STARTUP] ${label}: ${Date.now() - _startupTime}ms`);
-  }
-};
-_profile("script:start");
-_profile("import:ink");
-_profile("import:commander");
-_profile("import:repl");
-_profile("import:branding");
-_profile("import:executor");
-_profile("import:session");
-_profile("import:help");
-_profile("import:config");
-_profile("import:output-types");
-_profile("import:banner");
-_profile("import:debug");
-_profile("import:spec");
-_profile("import:headless");
-_profile("imports:complete");
+var profiler = initProfiler();
+var importsSpan = profiler.startSpan("imports", "Module Imports");
+profiler.memorySnapshot("script_start");
+profiler.checkpoint("import:ink");
+profiler.checkpoint("import:commander");
+profiler.checkpoint("import:repl");
+profiler.checkpoint("import:branding");
+profiler.checkpoint("import:executor");
+profiler.checkpoint("import:session");
+profiler.checkpoint("import:help");
+profiler.checkpoint("import:config");
+profiler.checkpoint("import:output-types");
+profiler.checkpoint("import:banner");
+profiler.checkpoint("import:debug");
+profiler.checkpoint("import:spec");
+profiler.checkpoint("import:headless");
+profiler.endSpan(importsSpan);
+profiler.memorySnapshot("imports_complete");
 var program2 = new Command();
-_profile("commander:created");
+profiler.checkpoint("commander:created");
 program2.configureHelp({
   formatHelp: () => formatRootHelp().join("\n")
 });
@@ -85559,12 +86289,28 @@ program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CL
       }
       const cliLogoMode = options.logo && isValidLogoMode(options.logo) ? options.logo : void 0;
       process.stdout.write("Initializing...");
+      const sessionInitSpan = profiler.startSpan(
+        "session_init",
+        "Session Initialization"
+      );
       const session = new REPLSession();
       await session.initialize();
+      profiler.endSpan(sessionInitSpan);
       debugProtocol.session("init", { mode: "repl" });
       emitSessionState(session);
       process.stdout.write("\r\x1B[K");
+      profiler.memorySnapshot("pre_banner");
+      printProfileReport();
       renderBanner(cliLogoMode, "startup");
+      if (session.isOfflineMode()) {
+        console.log("");
+        console.log(
+          `${colors.yellow}\u26A0\uFE0F  Offline Mode: API endpoint unreachable${colors.reset}`
+        );
+        console.log(
+          `${colors.dim}  Commands requiring API access will fail. Check network and try again.${colors.reset}`
+        );
+      }
       if (session.getAuthSource() === "profile-fallback") {
         const profileName = session.getActiveProfileName();
         console.log("");
@@ -85629,13 +86375,27 @@ program2.name(CLI_NAME).description("F5 Distributed Cloud Shell - Interactive CL
   }
 );
 async function executeNonInteractive(args) {
+  const sessionInitSpan = profiler.startSpan(
+    "session_init",
+    "Session Initialization"
+  );
   const session = new REPLSession();
   await session.initialize();
+  profiler.endSpan(sessionInitSpan);
+  printProfileReport();
   debugProtocol.session("init", {
     mode: "non-interactive",
     command: args.join(" ")
   });
   emitSessionState(session);
+  if (session.isOfflineMode()) {
+    console.error(
+      `${colors.yellow}\u26A0\uFE0F  Offline Mode: API endpoint unreachable${colors.reset}`
+    );
+    console.error(
+      `${colors.dim}  Commands requiring API access will fail.${colors.reset}`
+    );
+  }
   if (session.getAuthSource() === "profile-fallback") {
     const profileName = session.getActiveProfileName();
     console.error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@robinmordasiewicz/f5xc-xcsh",
-  "version": "2.0.21-2601100343",
+  "version": "2.0.21-2601101304",
   "description": "F5 Distributed Cloud Shell - Interactive CLI for F5 XC",
   "type": "module",
   "bin": {
@@ -25,8 +25,13 @@
     "build:binaries": "./scripts/build-binaries.sh",
     "build:release": "npm run build && npm run build:binaries",
     "dev": "tsx src/index.tsx",
+    "dev:profile": "XCSH_PROFILE_LEVEL=detailed tsx src/index.tsx",
+    "dev:profile:full": "XCSH_PROFILE_LEVEL=full tsx src/index.tsx",
     "build:dev": "npm run build && ${HOME}/.bun/bin/bun build dist/index.js --compile --outfile ./xcsh",
+    "build:dev:debug": "tsup --sourcemap && bun build dist/index.js --compile --outfile ./xcsh-debug",
     "start": "node dist/index.js",
+    "start:profile": "XCSH_PROFILE_LEVEL=detailed node dist/index.js",
+    "start:profile:full": "XCSH_PROFILE_LEVEL=full node dist/index.js",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
     "lint": "eslint src",