@xortex/xcode 3.0.0 → 3.0.2

package/hooks/useManagePlugins.ts

@@ -0,0 +1,304 @@
+import { useCallback, useEffect } from 'react'
+import type { Command } from '../commands.js'
+import { useNotifications } from '../context/notifications.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import { reinitializeLspServerManager } from '../services/lsp/manager.js'
+import { useAppState, useSetAppState } from '../state/AppState.js'
+import type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.js'
+import { count } from '../utils/array.js'
+import { logForDebugging } from '../utils/debug.js'
+import { logForDiagnosticsNoPII } from '../utils/diagLogs.js'
+import { toError } from '../utils/errors.js'
+import { logError } from '../utils/log.js'
+import { loadPluginAgents } from '../utils/plugins/loadPluginAgents.js'
+import { getPluginCommands } from '../utils/plugins/loadPluginCommands.js'
+import { loadPluginHooks } from '../utils/plugins/loadPluginHooks.js'
+import { loadPluginLspServers } from '../utils/plugins/lspPluginIntegration.js'
+import { loadPluginMcpServers } from '../utils/plugins/mcpPluginIntegration.js'
+import { detectAndUninstallDelistedPlugins } from '../utils/plugins/pluginBlocklist.js'
+import { getFlaggedPlugins } from '../utils/plugins/pluginFlagging.js'
+import { loadAllPlugins } from '../utils/plugins/pluginLoader.js'
+
+/**
+ * Hook to manage plugin state and synchronize with AppState.
+ *
+ * On mount: loads all plugins, runs delisting enforcement, surfaces flagged-
+ * plugin notifications, populates AppState.plugins. This is the initial
+ * Layer-3 load — subsequent refresh goes through /reload-plugins.
+ *
+ * On needsRefresh: shows a notification directing the user to /reload-plugins.
+ * Does NOT auto-refresh. All Layer-3 swap (commands, agents, hooks, MCP)
+ * goes through refreshActivePlugins() via /reload-plugins for one consistent
+ * mental model. See Outline: declarative-settings-hXHBMDIf4b PR 5c.
+ */
+export function useManagePlugins({
+  enabled = true,
+}: {
+  enabled?: boolean
+} = {}) {
+  const setAppState = useSetAppState()
+  const needsRefresh = useAppState(s => s.plugins.needsRefresh)
+  const { addNotification } = useNotifications()
+
+  // Initial plugin load. Runs once on mount. NOT used for refresh — all
+  // post-mount refresh goes through /reload-plugins → refreshActivePlugins().
+  // Unlike refreshActivePlugins, this also runs delisting enforcement and
+  // flagged-plugin notifications (session-start concerns), and does NOT bump
+  // mcp.pluginReconnectKey (MCP effects fire on their own mount).
+  const initialPluginLoad = useCallback(async () => {
+    try {
+      // Load all plugins - capture errors array
+      const { enabled, disabled, errors } = await loadAllPlugins()
+
+      // Detect delisted plugins, auto-uninstall them, and record as flagged.
+      await detectAndUninstallDelistedPlugins()
+
+      // Notify if there are flagged plugins pending dismissal
+      const flagged = getFlaggedPlugins()
+      if (Object.keys(flagged).length > 0) {
+        addNotification({
+          key: 'plugin-delisted-flagged',
+          text: 'Plugins flagged. Check /plugins',
+          color: 'warning',
+          priority: 'high',
+        })
+      }
+
+      // Load commands, agents, and hooks with individual error handling
+      // Errors are added to the errors array for user visibility in Doctor UI
+      let commands: Command[] = []
+      let agents: AgentDefinition[] = []
+
+      try {
+        commands = await getPluginCommands()
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error)
+        errors.push({
+          type: 'generic-error',
+          source: 'plugin-commands',
+          error: `Failed to load plugin commands: ${errorMessage}`,
+        })
+      }
+
+      try {
+        agents = await loadPluginAgents()
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error)
+        errors.push({
+          type: 'generic-error',
+          source: 'plugin-agents',
+          error: `Failed to load plugin agents: ${errorMessage}`,
+        })
+      }
+
+      try {
+        await loadPluginHooks()
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error)
+        errors.push({
+          type: 'generic-error',
+          source: 'plugin-hooks',
+          error: `Failed to load plugin hooks: ${errorMessage}`,
+        })
+      }
+
+      // Load MCP server configs per plugin to get an accurate count.
+      // LoadedPlugin.mcpServers is not populated by loadAllPlugins — it's a
+      // cache slot that extractMcpServersFromPlugins fills later, which races
+      // with this metric. Calling loadPluginMcpServers directly (as
+      // cli/handlers/plugins.ts does) gives the correct count and also
+      // warms the cache for the MCP connection manager.
+      //
+      // Runs BEFORE setAppState so any errors pushed by these loaders make it
+      // into AppState.plugins.errors (Doctor UI), not just telemetry.
+      const mcpServerCounts = await Promise.all(
+        enabled.map(async p => {
+          if (p.mcpServers) return Object.keys(p.mcpServers).length
+          const servers = await loadPluginMcpServers(p, errors)
+          if (servers) p.mcpServers = servers
+          return servers ? Object.keys(servers).length : 0
+        }),
+      )
+      const mcp_count = mcpServerCounts.reduce((sum, n) => sum + n, 0)
+
+      // LSP: the primary fix for issue #15521 is in refresh.ts (via
+      // performBackgroundPluginInstallations → refreshActivePlugins, which
+      // clears caches first). This reinit is defensive — it reads the same
+      // memoized loadAllPlugins() result as the original init unless a cache
+      // invalidation happened between main.tsx:3203 and REPL mount (e.g.
+      // seed marketplace registration or policySettings hot-reload).
+      const lspServerCounts = await Promise.all(
+        enabled.map(async p => {
+          if (p.lspServers) return Object.keys(p.lspServers).length
+          const servers = await loadPluginLspServers(p, errors)
+          if (servers) p.lspServers = servers
+          return servers ? Object.keys(servers).length : 0
+        }),
+      )
+      const lsp_count = lspServerCounts.reduce((sum, n) => sum + n, 0)
+      reinitializeLspServerManager()
+
+      // Update AppState - merge errors to preserve LSP errors
+      setAppState(prevState => {
+        // Keep existing LSP/non-plugin-loading errors (source 'lsp-manager' or 'plugin:*')
+        const existingLspErrors = prevState.plugins.errors.filter(
+          e => e.source === 'lsp-manager' || e.source.startsWith('plugin:'),
+        )
+        // Deduplicate: remove existing LSP errors that are also in new errors
+        const newErrorKeys = new Set(
+          errors.map(e =>
+            e.type === 'generic-error'
+              ? `generic-error:${e.source}:${e.error}`
+              : `${e.type}:${e.source}`,
+          ),
+        )
+        const filteredExisting = existingLspErrors.filter(e => {
+          const key =
+            e.type === 'generic-error'
+              ? `generic-error:${e.source}:${e.error}`
+              : `${e.type}:${e.source}`
+          return !newErrorKeys.has(key)
+        })
+        const mergedErrors = [...filteredExisting, ...errors]
+
+        return {
+          ...prevState,
+          plugins: {
+            ...prevState.plugins,
+            enabled,
+            disabled,
+            commands,
+            errors: mergedErrors,
+          },
+        }
+      })
+
+      logForDebugging(
+        `Loaded plugins - Enabled: ${enabled.length}, Disabled: ${disabled.length}, Commands: ${commands.length}, Agents: ${agents.length}, Errors: ${errors.length}`,
+      )
+
+      // Count component types across enabled plugins
+      const hook_count = enabled.reduce((sum, p) => {
+        if (!p.hooksConfig) return sum
+        return (
+          sum +
+          Object.values(p.hooksConfig).reduce(
+            (s, matchers) =>
+              s + (matchers?.reduce((h, m) => h + m.hooks.length, 0) ?? 0),
+            0,
+          )
+        )
+      }, 0)
+
+      return {
+        enabled_count: enabled.length,
+        disabled_count: disabled.length,
+        inline_count: count(enabled, p => p.source.endsWith('@inline')),
+        marketplace_count: count(enabled, p => !p.source.endsWith('@inline')),
+        error_count: errors.length,
+        skill_count: commands.length,
+        agent_count: agents.length,
+        hook_count,
+        mcp_count,
+        lsp_count,
+        // Ant-only: which plugins are enabled, to correlate with RSS/FPS.
+        // Kept separate from base metrics so it doesn't flow into
+        // logForDiagnosticsNoPII.
+        ant_enabled_names:
+          process.env.USER_TYPE === 'ant' && enabled.length > 0
+            ? (enabled
+                .map(p => p.name)
+                .sort()
+                .join(
+                  ',',
+                ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS)
+            : undefined,
+      }
+    } catch (error) {
+      // Only plugin loading errors should reach here - log for monitoring
+      const errorObj = toError(error)
+      logError(errorObj)
+      logForDebugging(`Error loading plugins: ${error}`)
+      // Set empty state on error, but preserve LSP errors and add the new error
+      setAppState(prevState => {
+        // Keep existing LSP/non-plugin-loading errors
+        const existingLspErrors = prevState.plugins.errors.filter(
+          e => e.source === 'lsp-manager' || e.source.startsWith('plugin:'),
+        )
+        const newError = {
+          type: 'generic-error' as const,
+          source: 'plugin-system',
+          error: errorObj.message,
+        }
+        return {
+          ...prevState,
+          plugins: {
+            ...prevState.plugins,
+            enabled: [],
+            disabled: [],
+            commands: [],
+            errors: [...existingLspErrors, newError],
+          },
+        }
+      })
+
+      return {
+        enabled_count: 0,
+        disabled_count: 0,
+        inline_count: 0,
+        marketplace_count: 0,
+        error_count: 1,
+        skill_count: 0,
+        agent_count: 0,
+        hook_count: 0,
+        mcp_count: 0,
+        lsp_count: 0,
+        load_failed: true,
+        ant_enabled_names: undefined,
+      }
+    }
+  }, [setAppState, addNotification])
+
+  // Load plugins on mount and emit telemetry
+  useEffect(() => {
+    if (!enabled) return
+    void initialPluginLoad().then(metrics => {
+      const { ant_enabled_names, ...baseMetrics } = metrics
+      const allMetrics = {
+        ...baseMetrics,
+        has_custom_plugin_cache_dir: !!process.env.CLAUDE_CODE_PLUGIN_CACHE_DIR,
+      }
+      logEvent('tengu_plugins_loaded', {
+        ...allMetrics,
+        ...(ant_enabled_names !== undefined && {
+          enabled_names: ant_enabled_names,
+        }),
+      })
+      logForDiagnosticsNoPII('info', 'tengu_plugins_loaded', allMetrics)
+    })
+  }, [initialPluginLoad, enabled])
+
+  // Plugin state changed on disk (background reconcile, /plugin menu,
+  // external settings edit). Show a notification; user runs /reload-plugins
+  // to apply. The previous auto-refresh here had a stale-cache bug (only
+  // cleared loadAllPlugins, downstream memoized loaders returned old data)
+  // and was incomplete (no MCP, no agentDefinitions). /reload-plugins
+  // handles all of that correctly via refreshActivePlugins().
+  useEffect(() => {
+    if (!enabled || !needsRefresh) return
+    addNotification({
+      key: 'plugin-reload-pending',
+      text: 'Plugins changed. Run /reload-plugins to activate.',
+      color: 'suggestion',
+      priority: 'low',
+    })
+    // Do NOT auto-refresh. Do NOT reset needsRefresh — /reload-plugins
+    // consumes it via refreshActivePlugins().
+  }, [enabled, needsRefresh, addNotification])
+}

package/hooks/useMemoryUsage.ts

@@ -0,0 +1,39 @@
+import { useState } from 'react'
+import { useInterval } from 'usehooks-ts'
+
+export type MemoryUsageStatus = 'normal' | 'high' | 'critical'
+
+export type MemoryUsageInfo = {
+  heapUsed: number
+  status: MemoryUsageStatus
+}
+
+const HIGH_MEMORY_THRESHOLD = 1.5 * 1024 * 1024 * 1024 // 1.5GB in bytes
+const CRITICAL_MEMORY_THRESHOLD = 2.5 * 1024 * 1024 * 1024 // 2.5GB in bytes
+
+/**
+ * Hook to monitor Node.js process memory usage.
+ * Polls every 10 seconds; returns null while status is 'normal'.
+ */
+export function useMemoryUsage(): MemoryUsageInfo | null {
+  const [memoryUsage, setMemoryUsage] = useState<MemoryUsageInfo | null>(null)
+
+  useInterval(() => {
+    const heapUsed = process.memoryUsage().heapUsed
+    const status: MemoryUsageStatus =
+      heapUsed >= CRITICAL_MEMORY_THRESHOLD
+        ? 'critical'
+        : heapUsed >= HIGH_MEMORY_THRESHOLD
+          ? 'high'
+          : 'normal'
+    setMemoryUsage(prev => {
+      // Bail when status is 'normal' — nothing is shown, so heapUsed is
+      // irrelevant and we avoid re-rendering the whole Notifications subtree
+      // every 10 seconds for the 99%+ of users who never reach 1.5GB.
+      if (status === 'normal') return prev === null ? prev : null
+      return { heapUsed, status }
+    })
+  }, 10_000)
+
+  return memoryUsage
+}

package/hooks/useMergedClients.ts

@@ -0,0 +1,23 @@
+import uniqBy from 'lodash-es/uniqBy.js'
+import { useMemo } from 'react'
+import type { MCPServerConnection } from '../services/mcp/types.js'
+
+export function mergeClients(
+  initialClients: MCPServerConnection[] | undefined,
+  mcpClients: readonly MCPServerConnection[] | undefined,
+): MCPServerConnection[] {
+  if (initialClients && mcpClients && mcpClients.length > 0) {
+    return uniqBy([...initialClients, ...mcpClients], 'name')
+  }
+  return initialClients || []
+}
+
+export function useMergedClients(
+  initialClients: MCPServerConnection[] | undefined,
+  mcpClients: MCPServerConnection[] | undefined,
+): MCPServerConnection[] {
+  return useMemo(
+    () => mergeClients(initialClients, mcpClients),
+    [initialClients, mcpClients],
+  )
+}

package/hooks/useMergedCommands.ts

@@ -0,0 +1,15 @@
+import uniqBy from 'lodash-es/uniqBy.js'
+import { useMemo } from 'react'
+import type { Command } from '../commands.js'
+
+export function useMergedCommands(
+  initialCommands: Command[],
+  mcpCommands: Command[],
+): Command[] {
+  return useMemo(() => {
+    if (mcpCommands.length > 0) {
+      return uniqBy([...initialCommands, ...mcpCommands], 'name')
+    }
+    return initialCommands
+  }, [initialCommands, mcpCommands])
+}

package/hooks/useMergedTools.ts

@@ -0,0 +1,44 @@
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { useMemo } from 'react'
+import type { Tools, ToolPermissionContext } from '../Tool.js'
+import { assembleToolPool } from '../tools.js'
+import { useAppState } from '../state/AppState.js'
+import { mergeAndFilterTools } from '../utils/toolPool.js'
+
+/**
+ * React hook that assembles the full tool pool for the REPL.
+ *
+ * Uses assembleToolPool() (the shared pure function used by both REPL and runAgent)
+ * to combine built-in tools with MCP tools, applying deny rules and deduplication.
+ * Any extra initialTools are merged on top.
+ *
+ * @param initialTools - Extra tools to include (built-in + startup MCP from props).
+ *   These are merged with the assembled pool and take precedence in deduplication.
+ * @param mcpTools - MCP tools discovered dynamically (from mcp state)
+ * @param toolPermissionContext - Permission context for filtering
+ */
+export function useMergedTools(
+  initialTools: Tools,
+  mcpTools: Tools,
+  toolPermissionContext: ToolPermissionContext,
+): Tools {
+  let replBridgeEnabled = false
+  let replBridgeOutboundOnly = false
+  return useMemo(() => {
+    // assembleToolPool is the shared function that both REPL and runAgent use.
+    // It handles: getTools() + MCP deny-rule filtering + dedup + MCP CLI exclusion.
+    const assembled = assembleToolPool(toolPermissionContext, mcpTools)
+
+    return mergeAndFilterTools(
+      initialTools,
+      assembled,
+      toolPermissionContext.mode,
+    )
+  }, [
+    initialTools,
+    mcpTools,
+    toolPermissionContext,
+    replBridgeEnabled,
+    replBridgeOutboundOnly,
+  ])
+}

package/hooks/useMinDisplayTime.ts

@@ -0,0 +1,35 @@
+import { useEffect, useRef, useState } from 'react'
+
+/**
+ * Throttles a value so each distinct value stays visible for at least `minMs`.
+ * Prevents fast-cycling progress text from flickering past before it's readable.
+ *
+ * Unlike debounce (wait for quiet) or throttle (limit rate), this guarantees
+ * each value gets its minimum screen time before being replaced.
+ */
+export function useMinDisplayTime<T>(value: T, minMs: number): T {
+  const [displayed, setDisplayed] = useState(value)
+  const lastShownAtRef = useRef(0)
+
+  useEffect(() => {
+    const elapsed = Date.now() - lastShownAtRef.current
+    if (elapsed >= minMs) {
+      lastShownAtRef.current = Date.now()
+      setDisplayed(value)
+      return
+    }
+    const timer = setTimeout(
+      (shownAtRef, setFn, v) => {
+        shownAtRef.current = Date.now()
+        setFn(v)
+      },
+      minMs - elapsed,
+      lastShownAtRef,
+      setDisplayed,
+      value,
+    )
+    return () => clearTimeout(timer)
+  }, [value, minMs])
+
+  return displayed
+}

package/hooks/useNotifyAfterTimeout.ts

@@ -0,0 +1,65 @@
+import { useEffect } from 'react'
+import {
+  getLastInteractionTime,
+  updateLastInteractionTime,
+} from '../bootstrap/state.js'
+import { useTerminalNotification } from '../ink/useTerminalNotification.js'
+import { sendNotification } from '../services/notifier.js'
+// The time threshold in milliseconds for considering an interaction "recent" (6 seconds)
+export const DEFAULT_INTERACTION_THRESHOLD_MS = 6000
+
+function getTimeSinceLastInteraction(): number {
+  return Date.now() - getLastInteractionTime()
+}
+
+function hasRecentInteraction(threshold: number): boolean {
+  return getTimeSinceLastInteraction() < threshold
+}
+
+function shouldNotify(threshold: number): boolean {
+  return process.env.NODE_ENV !== 'test' && !hasRecentInteraction(threshold)
+}
+
+// NOTE: User interaction tracking is now done in App.tsx's processKeysInBatch
+// function, which calls updateLastInteractionTime() when any input is received.
+// This avoids having a separate stdin 'data' listener that would compete with
+// the main 'readable' listener and cause dropped input characters.
+
+/**
+ * Hook that manages desktop notifications after a timeout period.
+ *
+ * Shows a notification in two cases:
+ * 1. Immediately if the app has been idle for longer than the threshold
+ * 2. After the specified timeout if the user doesn't interact within that time
+ *
+ * @param message - The notification message to display
+ * @param timeout - The timeout in milliseconds (defaults to 6000ms)
+ */
+export function useNotifyAfterTimeout(
+  message: string,
+  notificationType: string,
+): void {
+  const terminal = useTerminalNotification()
+
+  // Reset interaction time when hook is called to make sure that requests
+  // that took a long time to complete don't pop up a notification right away.
+  // Must be immediate because useEffect runs after Ink's render cycle has
+  // already flushed; without it the timestamp stays stale and a premature
+  // notification fires if the user is idle (no subsequent renders to flush).
+  useEffect(() => {
+    updateLastInteractionTime(true)
+  }, [])
+
+  useEffect(() => {
+    let hasNotified = false
+    const timer = setInterval(() => {
+      if (shouldNotify(DEFAULT_INTERACTION_THRESHOLD_MS) && !hasNotified) {
+        hasNotified = true
+        clearInterval(timer)
+        void sendNotification({ message, notificationType }, terminal)
+      }
+    }, DEFAULT_INTERACTION_THRESHOLD_MS)
+
+    return () => clearInterval(timer)
+  }, [message, notificationType, terminal])
+}

package/hooks/useOfficialMarketplaceNotification.tsx

@@ -0,0 +1,48 @@
+import * as React from 'react';
+import type { Notification } from '../context/notifications.js';
+import { Text } from '../ink.js';
+import { logForDebugging } from '../utils/debug.js';
+import { checkAndInstallOfficialMarketplace } from '../utils/plugins/officialMarketplaceStartupCheck.js';
+import { useStartupNotification } from './notifs/useStartupNotification.js';
+
+/**
+ * Hook that handles official marketplace auto-installation and shows
+ * notifications for success/failure in the bottom right of the REPL.
+ */
+export function useOfficialMarketplaceNotification() {
+  useStartupNotification(_temp);
+}
+async function _temp() {
+  const result = await checkAndInstallOfficialMarketplace();
+  const notifs = [];
+  if (result.configSaveFailed) {
+    logForDebugging("Showing marketplace config save failure notification");
+    notifs.push({
+      key: "marketplace-config-save-failed",
+      jsx: <Text color="error">Failed to save marketplace retry info · Check ~/.claude.json permissions</Text>,
+      priority: "immediate",
+      timeoutMs: 10000
+    });
+  }
+  if (result.installed) {
+    logForDebugging("Showing marketplace installation success notification");
+    notifs.push({
+      key: "marketplace-installed",
+      jsx: <Text color="success">✓ Anthropic marketplace installed · /plugin to see available plugins</Text>,
+      priority: "immediate",
+      timeoutMs: 7000
+    });
+  } else {
+    if (result.skipped && result.reason === "unknown") {
+      logForDebugging("Showing marketplace installation failure notification");
+      notifs.push({
+        key: "marketplace-install-failed",
+        jsx: <Text color="warning">Failed to install Anthropic marketplace · Will retry on next startup</Text>,
+        priority: "immediate",
+        timeoutMs: 8000
+      });
+    }
+  }
+  return notifs;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIk5vdGlmaWNhdGlvbiIsIlRleHQiLCJsb2dGb3JEZWJ1Z2dpbmciLCJjaGVja0FuZEluc3RhbGxPZmZpY2lhbE1hcmtldHBsYWNlIiwidXNlU3RhcnR1cE5vdGlmaWNhdGlvbiIsInVzZU9mZmljaWFsTWFya2V0cGxhY2VOb3RpZmljYXRpb24iLCJfdGVtcCIsInJlc3VsdCIsIm5vdGlmcyIsImNvbmZpZ1NhdmVGYWlsZWQiLCJwdXNoIiwia2V5IiwianN4IiwicHJpb3JpdHkiLCJ0aW1lb3V0TXMiLCJpbnN0YWxsZWQiLCJza2lwcGVkIiwicmVhc29uIl0sInNvdXJjZXMiOlsidXNlT2ZmaWNpYWxNYXJrZXRwbGFjZU5vdGlmaWNhdGlvbi50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgUmVhY3QgZnJvbSAncmVhY3QnXG5pbXBvcnQgdHlwZSB7IE5vdGlmaWNhdGlvbiB9IGZyb20gJy4uL2NvbnRleHQvbm90aWZpY2F0aW9ucy5qcydcbmltcG9ydCB7IFRleHQgfSBmcm9tICcuLi9pbmsuanMnXG5pbXBvcnQgeyBsb2dGb3JEZWJ1Z2dpbmcgfSBmcm9tICcuLi91dGlscy9kZWJ1Zy5qcydcbmltcG9ydCB7IGNoZWNrQW5kSW5zdGFsbE9mZmljaWFsTWFya2V0cGxhY2UgfSBmcm9tICcuLi91dGlscy9wbHVnaW5zL29mZmljaWFsTWFya2V0cGxhY2VTdGFydHVwQ2hlY2suanMnXG5pbXBvcnQgeyB1c2VTdGFydHVwTm90aWZpY2F0aW9uIH0gZnJvbSAnLi9ub3RpZnMvdXNlU3RhcnR1cE5vdGlmaWNhdGlvbi5qcydcblxuLyoqXG4gKiBIb29rIHRoYXQgaGFuZGxlcyBvZmZpY2lhbCBtYXJrZXRwbGFjZSBhdXRvLWluc3RhbGxhdGlvbiBhbmQgc2hvd3NcbiAqIG5vdGlmaWNhdGlvbnMgZm9yIHN1Y2Nlc3MvZmFpbHVyZSBpbiB0aGUgYm90dG9tIHJpZ2h0IG9mIHRoZSBSRVBMLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdXNlT2ZmaWNpYWxNYXJrZXRwbGFjZU5vdGlmaWNhdGlvbigpOiB2b2lkIHtcbiAgdXNlU3RhcnR1cE5vdGlmaWNhdGlvbihhc3luYyAoKSA9PiB7XG4gICAgY29uc3QgcmVzdWx0ID0gYXdhaXQgY2hlY2tBbmRJbnN0YWxsT2ZmaWNpYWxNYXJrZXRwbGFjZSgpXG4gICAgY29uc3Qgbm90aWZzOiBOb3RpZmljYXRpb25bXSA9IFtdXG5cbiAgICAvLyBDaGVjayBmb3IgY29uZmlnIHNhdmUgZmFpbHVyZSBmaXJzdCAtIHRoaXMgaXMgY3JpdGljYWxcbiAgICBpZiAocmVzdWx0LmNvbmZpZ1NhdmVGYWlsZWQpIHtcbiAgICAgIGxvZ0ZvckRlYnVnZ2luZygnU2hvd2luZyBtYXJrZXRwbGFjZSBjb25maWcgc2F2ZSBmYWlsdXJlIG5vdGlmaWNhdGlvbicpXG4gICAgICBub3RpZnMucHVzaCh7XG4gICAgICAgIGtleTogJ21hcmtldHBsYWNlLWNvbmZpZy1zYXZlLWZhaWxlZCcsXG4gICAgICAgIGpzeDogKFxuICAgICAgICAgIDxUZXh0IGNvbG9yPVwiZXJyb3JcIj5cbiAgICAgICAgICAgIEZhaWxlZCB0byBzYXZlIG1hcmtldHBsYWNlIHJldHJ5IGluZm8gwrcgQ2hlY2sgfi8uY2xhdWRlLmpzb25cbiAgICAgICAgICAgIHBlcm1pc3Npb25zXG4gICAgICAgICAgPC9UZXh0PlxuICAgICAgICApLFxuICAgICAgICBwcmlvcml0eTogJ2ltbWVkaWF0ZScsXG4gICAgICAgIHRpbWVvdXRNczogMTAwMDAsXG4gICAgICB9KVxuICAgIH1cblxuICAgIGlmIChyZXN1bHQuaW5zdGFsbGVkKSB7XG4gICAgICBsb2dGb3JEZWJ1Z2dpbmcoJ1Nob3dpbmcgbWFya2V0cGxhY2UgaW5zdGFsbGF0aW9uIHN1Y2Nlc3Mgbm90aWZpY2F0aW9uJylcbiAgICAgIG5vdGlmcy5wdXNoKHtcbiAgICAgICAga2V5OiAnbWFya2V0cGxhY2UtaW5zdGFsbGVkJyxcbiAgICAgICAganN4OiAoXG4gICAgICAgICAgPFRleHQgY29sb3I9XCJzdWNjZXNzXCI+XG4gICAgICAgICAgICDinJMgQW50aHJvcGljIG1hcmtldHBsYWNlIGluc3RhbGxlZCDCtyAvcGx1Z2luIHRvIHNlZSBhdmFpbGFibGUgcGx1Z2luc1xuICAgICAgICAgIDwvVGV4dD5cbiAgICAgICAgKSxcbiAgICAgICAgcHJpb3JpdHk6ICdpbW1lZGlhdGUnLFxuICAgICAgICB0aW1lb3V0TXM6IDcwMDAsXG4gICAgICB9KVxuICAgIH0gZWxzZSBpZiAocmVzdWx0LnNraXBwZWQgJiYgcmVzdWx0LnJlYXNvbiA9PT0gJ3Vua25vd24nKSB7XG4gICAgICBsb2dGb3JEZWJ1Z2dpbmcoJ1Nob3dpbmcgbWFya2V0cGxhY2UgaW5zdGFsbGF0aW9uIGZhaWx1cmUgbm90aWZpY2F0aW9uJylcbiAgICAgIG5vdGlmcy5wdXNoKHtcbiAgICAgICAga2V5OiAnbWFya2V0cGxhY2UtaW5zdGFsbC1mYWlsZWQnLFxuICAgICAgICBqc3g6IChcbiAgICAgICAgICA8VGV4dCBjb2xvcj1cIndhcm5pbmdcIj5cbiAgICAgICAgICAgIEZhaWxlZCB0byBpbnN0YWxsIEFudGhyb3BpYyBtYXJrZXRwbGFjZSDCtyBXaWxsIHJldHJ5IG9uIG5leHQgc3RhcnR1cFxuICAgICAgICAgIDwvVGV4dD5cbiAgICAgICAgKSxcbiAgICAgICAgcHJpb3JpdHk6ICdpbW1lZGlhdGUnLFxuICAgICAgICB0aW1lb3V0TXM6IDgwMDAsXG4gICAgICB9KVxuICAgIH1cbiAgICAvLyBEb24ndCBzaG93IG5vdGlmaWNhdGlvbnMgZm9yOlxuICAgIC8vIC0gYWxyZWFkeV9pbnN0YWxsZWQgKHVzZXIgYWxyZWFkeSBoYXMgaXQpXG4gICAgLy8gLSBwb2xpY3lfYmxvY2tlZCAoZW50ZXJwcmlzZSBwb2xpY3ksIGRvbid0IG5hZylcbiAgICAvLyAtIGFscmVhZHlfYXR0ZW1wdGVkIChoYW5kbGVkIGJ5IHJldHJ5IGxvZ2ljIG5vdylcbiAgICAvLyAtIGdpdF91bmF2YWlsYWJsZSAobWFya2V0cGxhY2UgaXMgYSBuaWNlLXRvLWhhdmU7IGlmIGdpdCBpcyBtaXNzaW5nXG4gICAgLy8gICBvciBpcyBhIG5vbi1mdW5jdGlvbmFsIG1hY09TIHhjcnVuIHNoaW0sIHJldHJ5IHNpbGVudGx5IG9uIGJhY2tvZmZcbiAgICAvLyAgIHJhdGhlciB0aGFuIG5hZ2dpbmcg4oCUIHRoZSB1c2VyIHdpbGwgc29ydCBnaXQgb3V0IGZvciBvdGhlciByZWFzb25zKVxuICAgIHJldHVybiBub3RpZnNcbiAgfSlcbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLQSxLQUFLLE1BQU0sT0FBTztBQUM5QixjQUFjQyxZQUFZLFFBQVEsNkJBQTZCO0FBQy9ELFNBQVNDLElBQUksUUFBUSxXQUFXO0FBQ2hDLFNBQVNDLGVBQWUsUUFBUSxtQkFBbUI7QUFDbkQsU0FBU0Msa0NBQWtDLFFBQVEscURBQXFEO0FBQ3hHLFNBQVNDLHNCQUFzQixRQUFRLG9DQUFvQzs7QUFFM0U7QUFDQTtBQUNBO0FBQ0E7QUFDQSxPQUFPLFNBQUFDLG1DQUFBO0VBQ0xELHNCQUFzQixDQUFDRSxLQXFEdEIsQ0FBQztBQUFBO0FBdERHLGVBQUFBLE1BQUE7RUFFSCxNQUFBQyxNQUFBLEdBQWUsTUFBTUosa0NBQWtDLENBQUMsQ0FBQztFQUN6RCxNQUFBSyxNQUFBLEdBQStCLEVBQUU7RUFHakMsSUFBSUQsTUFBTSxDQUFBRSxnQkFBaUI7SUFDekJQLGVBQWUsQ0FBQyxzREFBc0QsQ0FBQztJQUN2RU0sTUFBTSxDQUFBRSxJQUFLLENBQUM7TUFBQUMsR0FBQSxFQUNMLGdDQUFnQztNQUFBQyxHQUFBLEVBRW5DLENBQUMsSUFBSSxDQUFPLEtBQU8sQ0FBUCxPQUFPLENBQUMsd0VBR3BCLEVBSEMsSUFBSSxDQUdFO01BQUFDLFFBQUEsRUFFQyxXQUFXO01BQUFDLFNBQUEsRUFDVjtJQUNiLENBQUMsQ0FBQztFQUFBO0VBR0osSUFBSVAsTUFBTSxDQUFBUSxTQUFVO0lBQ2xCYixlQUFlLENBQUMsdURBQXVELENBQUM7SUFDeEVNLE1BQU0sQ0FBQUUsSUFBSyxDQUFDO01BQUFDLEdBQUEsRUFDTCx1QkFBdUI7TUFBQUMsR0FBQSxFQUUxQixDQUFDLElBQUksQ0FBTyxLQUFTLENBQVQsU0FBUyxDQUFDLG9FQUV0QixFQUZDLElBQUksQ0FFRTtNQUFBQyxRQUFBLEVBRUMsV0FBVztNQUFBQyxTQUFBLEVBQ1Y7SUFDYixDQUFDLENBQUM7RUFBQTtJQUNHLElBQUlQLE1BQU0sQ0FBQVMsT0FBdUMsSUFBM0JULE1BQU0sQ0FBQVUsTUFBTyxLQUFLLFNBQVM7TUFDdERmLGVBQWUsQ0FBQyx1REFBdUQsQ0FBQztNQUN4RU0sTUFBTSxDQUFBRSxJQUFLLENBQUM7UUFBQUMsR0FBQSxFQUNMLDRCQUE0QjtRQUFBQyxHQUFBLEVBRS9CLENBQUMsSUFBSSxDQUFPLEtBQVMsQ0FBVCxTQUFTLENBQUMsb0VBRXRCLEVBRkMsSUFBSSxDQUVFO1FBQUFDLFFBQUEsRUFFQyxXQUFXO1FBQUFDLFNBQUEsRUFDVjtNQUNiLENBQUMsQ0FBQztJQUFBO0VBQ0g7RUFBQSxPQVFNTixNQUFNO0FBQUEiLCJpZ25vcmVMaXN0IjpbXX0=