@xortex/xcode 3.0.0

package/utils/plugins/loadPluginHooks.ts

@@ -0,0 +1,287 @@
+import memoize from 'lodash-es/memoize.js'
+import type { HookEvent } from 'src/entrypoints/agentSdkTypes.js'
+import {
+  clearRegisteredPluginHooks,
+  getRegisteredHooks,
+  registerHookCallbacks,
+} from '../../bootstrap/state.js'
+import type { LoadedPlugin } from '../../types/plugin.js'
+import { logForDebugging } from '../debug.js'
+import { settingsChangeDetector } from '../settings/changeDetector.js'
+import {
+  getSettings_DEPRECATED,
+  getSettingsForSource,
+} from '../settings/settings.js'
+import type { PluginHookMatcher } from '../settings/types.js'
+import { jsonStringify } from '../slowOperations.js'
+import { clearPluginCache, loadAllPluginsCacheOnly } from './pluginLoader.js'
+
+// Track if hot reload subscription is set up
+let hotReloadSubscribed = false
+
+// Snapshot of enabledPlugins for change detection in hot reload
+let lastPluginSettingsSnapshot: string | undefined
+
+/**
+ * Convert plugin hooks configuration to native matchers with plugin context
+ */
+function convertPluginHooksToMatchers(
+  plugin: LoadedPlugin,
+): Record<HookEvent, PluginHookMatcher[]> {
+  const pluginMatchers: Record<HookEvent, PluginHookMatcher[]> = {
+    PreToolUse: [],
+    PostToolUse: [],
+    PostToolUseFailure: [],
+    PermissionDenied: [],
+    Notification: [],
+    UserPromptSubmit: [],
+    SessionStart: [],
+    SessionEnd: [],
+    Stop: [],
+    StopFailure: [],
+    SubagentStart: [],
+    SubagentStop: [],
+    PreCompact: [],
+    PostCompact: [],
+    PermissionRequest: [],
+    Setup: [],
+    TeammateIdle: [],
+    TaskCreated: [],
+    TaskCompleted: [],
+    Elicitation: [],
+    ElicitationResult: [],
+    ConfigChange: [],
+    WorktreeCreate: [],
+    WorktreeRemove: [],
+    InstructionsLoaded: [],
+    CwdChanged: [],
+    FileChanged: [],
+  }
+
+  if (!plugin.hooksConfig) {
+    return pluginMatchers
+  }
+
+  // Process each hook event - pass through all hook types with plugin context
+  for (const [event, matchers] of Object.entries(plugin.hooksConfig)) {
+    const hookEvent = event as HookEvent
+    if (!pluginMatchers[hookEvent]) {
+      continue
+    }
+
+    for (const matcher of matchers) {
+      if (matcher.hooks.length > 0) {
+        pluginMatchers[hookEvent].push({
+          matcher: matcher.matcher,
+          hooks: matcher.hooks,
+          pluginRoot: plugin.path,
+          pluginName: plugin.name,
+          pluginId: plugin.source,
+        })
+      }
+    }
+  }
+
+  return pluginMatchers
+}
+
+/**
+ * Load and register hooks from all enabled plugins
+ */
+export const loadPluginHooks = memoize(async (): Promise<void> => {
+  const { enabled } = await loadAllPluginsCacheOnly()
+  const allPluginHooks: Record<HookEvent, PluginHookMatcher[]> = {
+    PreToolUse: [],
+    PostToolUse: [],
+    PostToolUseFailure: [],
+    PermissionDenied: [],
+    Notification: [],
+    UserPromptSubmit: [],
+    SessionStart: [],
+    SessionEnd: [],
+    Stop: [],
+    StopFailure: [],
+    SubagentStart: [],
+    SubagentStop: [],
+    PreCompact: [],
+    PostCompact: [],
+    PermissionRequest: [],
+    Setup: [],
+    TeammateIdle: [],
+    TaskCreated: [],
+    TaskCompleted: [],
+    Elicitation: [],
+    ElicitationResult: [],
+    ConfigChange: [],
+    WorktreeCreate: [],
+    WorktreeRemove: [],
+    InstructionsLoaded: [],
+    CwdChanged: [],
+    FileChanged: [],
+  }
+
+  // Process each enabled plugin
+  for (const plugin of enabled) {
+    if (!plugin.hooksConfig) {
+      continue
+    }
+
+    logForDebugging(`Loading hooks from plugin: ${plugin.name}`)
+    const pluginMatchers = convertPluginHooksToMatchers(plugin)
+
+    // Merge plugin hooks into the main collection
+    for (const event of Object.keys(pluginMatchers) as HookEvent[]) {
+      allPluginHooks[event].push(...pluginMatchers[event])
+    }
+  }
+
+  // Clear-then-register as an atomic pair. Previously the clear lived in
+  // clearPluginHookCache(), which meant any clearAllCaches() call (from
+  // /plugins UI, pluginInstallationHelpers, thinkback, etc.) wiped plugin
+  // hooks from STATE.registeredHooks and left them wiped until someone
+  // happened to call loadPluginHooks() again. SessionStart explicitly awaits
+  // loadPluginHooks() before firing so it always re-registered; Stop has no
+  // such guard, so plugin Stop hooks silently never fired after any plugin
+  // management operation (gh-29767). Doing the clear here makes the swap
+  // atomic — old hooks stay valid until this point, new hooks take over.
+  clearRegisteredPluginHooks()
+  registerHookCallbacks(allPluginHooks)
+
+  const totalHooks = Object.values(allPluginHooks).reduce(
+    (sum, matchers) => sum + matchers.reduce((s, m) => s + m.hooks.length, 0),
+    0,
+  )
+  logForDebugging(
+    `Registered ${totalHooks} hooks from ${enabled.length} plugins`,
+  )
+})
+
+export function clearPluginHookCache(): void {
+  // Only invalidate the memoize — do NOT wipe STATE.registeredHooks here.
+  // Wiping here left plugin hooks dead between clearAllCaches() and the next
+  // loadPluginHooks() call, which for Stop hooks might never happen
+  // (gh-29767). The clear now lives inside loadPluginHooks() as an atomic
+  // clear-then-register, so old hooks stay valid until the fresh load swaps
+  // them out.
+  loadPluginHooks.cache?.clear?.()
+}
+
+/**
+ * Remove hooks from plugins no longer in the enabled set, without adding
+ * hooks from newly-enabled plugins. Called from clearAllCaches() so
+ * uninstalled/disabled plugins stop firing hooks immediately (gh-36995),
+ * while newly-enabled plugins wait for /reload-plugins — consistent with
+ * how commands/agents/MCP behave.
+ *
+ * The full swap (clear + register all) still happens via loadPluginHooks(),
+ * which /reload-plugins awaits.
+ */
+export async function pruneRemovedPluginHooks(): Promise<void> {
+  // Early return when nothing to prune — avoids seeding the loadAllPluginsCacheOnly
+  // memoize in test/preload.ts beforeEach (which clears registeredHooks).
+  if (!getRegisteredHooks()) return
+  const { enabled } = await loadAllPluginsCacheOnly()
+  const enabledRoots = new Set(enabled.map(p => p.path))
+
+  // Re-read after the await: a concurrent loadPluginHooks() (hot-reload)
+  // could have swapped STATE.registeredHooks during the gap. Holding the
+  // pre-await reference would compute survivors from stale data.
+  const current = getRegisteredHooks()
+  if (!current) return
+
+  // Collect plugin hooks whose pluginRoot is still enabled, then swap via
+  // the existing clear+register pair (same atomic-pair pattern as
+  // loadPluginHooks above). Callback hooks are preserved by
+  // clearRegisteredPluginHooks; we only need to re-register survivors.
+  const survivors: Partial<Record<HookEvent, PluginHookMatcher[]>> = {}
+  for (const [event, matchers] of Object.entries(current)) {
+    const kept = matchers.filter(
+      (m): m is PluginHookMatcher =>
+        'pluginRoot' in m && enabledRoots.has(m.pluginRoot),
+    )
+    if (kept.length > 0) survivors[event as HookEvent] = kept
+  }
+
+  clearRegisteredPluginHooks()
+  registerHookCallbacks(survivors)
+}
+
+/**
+ * Reset hot reload subscription state. Only for testing.
+ */
+export function resetHotReloadState(): void {
+  hotReloadSubscribed = false
+  lastPluginSettingsSnapshot = undefined
+}
+
+/**
+ * Build a stable string snapshot of the settings that feed into
+ * `loadAllPluginsCacheOnly()` for change detection. Sorts keys so comparison is
+ * deterministic regardless of insertion order.
+ *
+ * Hashes FOUR fields — not just enabledPlugins — because the memoized
+ * loadAllPluginsCacheOnly() also reads strictKnownMarketplaces, blockedMarketplaces
+ * (pluginLoader.ts:1933 via getBlockedMarketplaces), and
+ * extraKnownMarketplaces. If remote managed settings set only one of
+ * these (no enabledPlugins), a snapshot keyed only on enabledPlugins
+ * would never diff, the listener would skip, and the memoized result
+ * would retain the pre-remote marketplace allow/blocklist.
+ * See #23085 / #23152 poisoned-cache discussion (Slack C09N89L3VNJ).
+ */
+// Exported for testing — the listener at setupPluginHookHotReload uses this
+// for change detection; tests verify it diffs on the fields that matter.
+export function getPluginAffectingSettingsSnapshot(): string {
+  const merged = getSettings_DEPRECATED()
+  const policy = getSettingsForSource('policySettings')
+  // Key-sort the two Record fields so insertion order doesn't flap the hash.
+  // Array fields (strictKnownMarketplaces, blockedMarketplaces) have
+  // schema-stable order.
+  const sortKeys = <T extends Record<string, unknown>>(o: T | undefined) =>
+    o ? Object.fromEntries(Object.entries(o).sort()) : {}
+  return jsonStringify({
+    enabledPlugins: sortKeys(merged.enabledPlugins),
+    extraKnownMarketplaces: sortKeys(merged.extraKnownMarketplaces),
+    strictKnownMarketplaces: policy?.strictKnownMarketplaces ?? [],
+    blockedMarketplaces: policy?.blockedMarketplaces ?? [],
+  })
+}
+
+/**
+ * Set up hot reload for plugin hooks when remote settings change.
+ * When policySettings changes (e.g., from remote managed settings),
+ * compares the plugin-affecting settings snapshot and only reloads if it
+ * actually changed.
+ */
+export function setupPluginHookHotReload(): void {
+  if (hotReloadSubscribed) {
+    return
+  }
+  hotReloadSubscribed = true
+
+  // Capture the initial snapshot so the first policySettings change can compare
+  lastPluginSettingsSnapshot = getPluginAffectingSettingsSnapshot()
+
+  settingsChangeDetector.subscribe(source => {
+    if (source === 'policySettings') {
+      const newSnapshot = getPluginAffectingSettingsSnapshot()
+      if (newSnapshot === lastPluginSettingsSnapshot) {
+        logForDebugging(
+          'Plugin hooks: skipping reload, plugin-affecting settings unchanged',
+        )
+        return
+      }
+
+      lastPluginSettingsSnapshot = newSnapshot
+      logForDebugging(
+        'Plugin hooks: reloading due to plugin-affecting settings change',
+      )
+
+      // Clear all plugin-related caches
+      clearPluginCache('loadPluginHooks: plugin-affecting settings changed')
+      clearPluginHookCache()
+
+      // Reload hooks (fire-and-forget, don't block)
+      void loadPluginHooks()
+    }
+  })
+}

package/utils/plugins/loadPluginOutputStyles.ts

@@ -0,0 +1,178 @@
+import memoize from 'lodash-es/memoize.js'
+import { basename } from 'path'
+import type { OutputStyleConfig } from '../../constants/outputStyles.js'
+import { getPluginErrorMessage } from '../../types/plugin.js'
+import { logForDebugging } from '../debug.js'
+import {
+  coerceDescriptionToString,
+  parseFrontmatter,
+} from '../frontmatterParser.js'
+import { getFsImplementation, isDuplicatePath } from '../fsOperations.js'
+import { extractDescriptionFromMarkdown } from '../markdownConfigLoader.js'
+import { loadAllPluginsCacheOnly } from './pluginLoader.js'
+import { walkPluginMarkdown } from './walkPluginMarkdown.js'
+
+async function loadOutputStylesFromDirectory(
+  outputStylesPath: string,
+  pluginName: string,
+  loadedPaths: Set<string>,
+): Promise<OutputStyleConfig[]> {
+  const styles: OutputStyleConfig[] = []
+  await walkPluginMarkdown(
+    outputStylesPath,
+    async fullPath => {
+      const style = await loadOutputStyleFromFile(
+        fullPath,
+        pluginName,
+        loadedPaths,
+      )
+      if (style) styles.push(style)
+    },
+    { logLabel: 'output-styles' },
+  )
+  return styles
+}
+
+async function loadOutputStyleFromFile(
+  filePath: string,
+  pluginName: string,
+  loadedPaths: Set<string>,
+): Promise<OutputStyleConfig | null> {
+  const fs = getFsImplementation()
+  if (isDuplicatePath(fs, filePath, loadedPaths)) {
+    return null
+  }
+  try {
+    const content = await fs.readFile(filePath, { encoding: 'utf-8' })
+    const { frontmatter, content: markdownContent } = parseFrontmatter(
+      content,
+      filePath,
+    )
+
+    const fileName = basename(filePath, '.md')
+    const baseStyleName = (frontmatter.name as string) || fileName
+    // Namespace output styles with plugin name, consistent with commands and agents
+    const name = `${pluginName}:${baseStyleName}`
+    const description =
+      coerceDescriptionToString(frontmatter.description, name) ??
+      extractDescriptionFromMarkdown(
+        markdownContent,
+        `Output style from ${pluginName} plugin`,
+      )
+
+    // Parse forceForPlugin flag (supports both boolean and string values)
+    const forceRaw = frontmatter['force-for-plugin']
+    const forceForPlugin =
+      forceRaw === true || forceRaw === 'true'
+        ? true
+        : forceRaw === false || forceRaw === 'false'
+          ? false
+          : undefined
+
+    return {
+      name,
+      description,
+      prompt: markdownContent.trim(),
+      source: 'plugin',
+      forceForPlugin,
+    }
+  } catch (error) {
+    logForDebugging(`Failed to load output style from ${filePath}: ${error}`, {
+      level: 'error',
+    })
+    return null
+  }
+}
+
+export const loadPluginOutputStyles = memoize(
+  async (): Promise<OutputStyleConfig[]> => {
+    // Only load output styles from enabled plugins
+    const { enabled, errors } = await loadAllPluginsCacheOnly()
+    const allStyles: OutputStyleConfig[] = []
+
+    if (errors.length > 0) {
+      logForDebugging(
+        `Plugin loading errors: ${errors.map(e => getPluginErrorMessage(e)).join(', ')}`,
+      )
+    }
+
+    for (const plugin of enabled) {
+      // Track loaded file paths to prevent duplicates within this plugin
+      const loadedPaths = new Set<string>()
+
+      // Load output styles from default output-styles directory
+      if (plugin.outputStylesPath) {
+        try {
+          const styles = await loadOutputStylesFromDirectory(
+            plugin.outputStylesPath,
+            plugin.name,
+            loadedPaths,
+          )
+          allStyles.push(...styles)
+
+          if (styles.length > 0) {
+            logForDebugging(
+              `Loaded ${styles.length} output styles from plugin ${plugin.name} default directory`,
+            )
+          }
+        } catch (error) {
+          logForDebugging(
+            `Failed to load output styles from plugin ${plugin.name} default directory: ${error}`,
+            { level: 'error' },
+          )
+        }
+      }
+
+      // Load output styles from additional paths specified in manifest
+      if (plugin.outputStylesPaths) {
+        for (const stylePath of plugin.outputStylesPaths) {
+          try {
+            const fs = getFsImplementation()
+            const stats = await fs.stat(stylePath)
+
+            if (stats.isDirectory()) {
+              // Load all .md files from directory
+              const styles = await loadOutputStylesFromDirectory(
+                stylePath,
+                plugin.name,
+                loadedPaths,
+              )
+              allStyles.push(...styles)
+
+              if (styles.length > 0) {
+                logForDebugging(
+                  `Loaded ${styles.length} output styles from plugin ${plugin.name} custom path: ${stylePath}`,
+                )
+              }
+            } else if (stats.isFile() && stylePath.endsWith('.md')) {
+              // Load single output style file
+              const style = await loadOutputStyleFromFile(
+                stylePath,
+                plugin.name,
+                loadedPaths,
+              )
+              if (style) {
+                allStyles.push(style)
+                logForDebugging(
+                  `Loaded output style from plugin ${plugin.name} custom file: ${stylePath}`,
+                )
+              }
+            }
+          } catch (error) {
+            logForDebugging(
+              `Failed to load output styles from plugin ${plugin.name} custom path ${stylePath}: ${error}`,
+              { level: 'error' },
+            )
+          }
+        }
+      }
+    }
+
+    logForDebugging(`Total plugin output styles loaded: ${allStyles.length}`)
+    return allStyles
+  },
+)
+
+export function clearPluginOutputStyleCache(): void {
+  loadPluginOutputStyles.cache?.clear?.()
+}