@xelauvas/xela-cli 0.1.0

package/src/hooks/notifs/useLspInitializationNotification.tsx

@@ -0,0 +1,143 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useInterval } from 'usehooks-ts';
+import { getIsRemoteMode, getIsScrollDraining } from '../../bootstrap/state.js';
+import { useNotifications } from '../../context/notifications.js';
+import { Text } from '../../ink.js';
+import { getInitializationStatus, getLspServerManager } from '../../services/lsp/manager.js';
+import { useSetAppState } from '../../state/AppState.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+const LSP_POLL_INTERVAL_MS = 5000;
+
+/**
+ * Hook that polls LSP status and shows a notification when:
+ * 1. Manager initialization fails
+ * 2. Any LSP server enters an error state
+ *
+ * Also adds errors to appState.plugins.errors for /doctor display.
+ *
+ * Only active when ENABLE_LSP_TOOL is set.
+ */
+export function useLspInitializationNotification() {
+  const $ = _c(10);
+  const {
+    addNotification
+  } = useNotifications();
+  const setAppState = useSetAppState();
+  const [shouldPoll, setShouldPoll] = React.useState(_temp);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = new Set();
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const notifiedErrorsRef = React.useRef(t0);
+  let t1;
+  if ($[1] !== addNotification || $[2] !== setAppState) {
+    t1 = (source, errorMessage) => {
+      const errorKey = `${source}:${errorMessage}`;
+      if (notifiedErrorsRef.current.has(errorKey)) {
+        return;
+      }
+      notifiedErrorsRef.current.add(errorKey);
+      logForDebugging(`LSP error: ${source} - ${errorMessage}`);
+      setAppState(prev => {
+        const existingKeys = new Set(prev.plugins.errors.map(_temp2));
+        const stateErrorKey = `generic-error:${source}:${errorMessage}`;
+        if (existingKeys.has(stateErrorKey)) {
+          return prev;
+        }
+        return {
+          ...prev,
+          plugins: {
+            ...prev.plugins,
+            errors: [...prev.plugins.errors, {
+              type: "generic-error" as const,
+              source,
+              error: errorMessage
+            }]
+          }
+        };
+      });
+      const displayName = source.startsWith("plugin:") ? source.split(":")[1] ?? source : source;
+      addNotification({
+        key: `lsp-error-${source}`,
+        jsx: <><Text color="error">LSP for {displayName} failed</Text><Text dimColor={true}> · /plugin for details</Text></>,
+        priority: "medium",
+        timeoutMs: 8000
+      });
+    };
+    $[1] = addNotification;
+    $[2] = setAppState;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const addError = t1;
+  let t2;
+  if ($[4] !== addError) {
+    t2 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (getIsScrollDraining()) {
+        return;
+      }
+      const status = getInitializationStatus();
+      if (status.status === "failed") {
+        addError("lsp-manager", status.error.message);
+        setShouldPoll(false);
+        return;
+      }
+      if (status.status === "pending" || status.status === "not-started") {
+        return;
+      }
+      const manager = getLspServerManager();
+      if (manager) {
+        const servers = manager.getAllServers();
+        for (const [serverName, server] of servers) {
+          if (server.state === "error" && server.lastError) {
+            addError(serverName, server.lastError.message);
+          }
+        }
+      }
+    };
+    $[4] = addError;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const poll = t2;
+  useInterval(poll, shouldPoll ? LSP_POLL_INTERVAL_MS : null);
+  let t3;
+  let t4;
+  if ($[6] !== poll || $[7] !== shouldPoll) {
+    t3 = () => {
+      if (getIsRemoteMode() || !shouldPoll) {
+        return;
+      }
+      poll();
+    };
+    t4 = [poll, shouldPoll];
+    $[6] = poll;
+    $[7] = shouldPoll;
+    $[8] = t3;
+    $[9] = t4;
+  } else {
+    t3 = $[8];
+    t4 = $[9];
+  }
+  React.useEffect(t3, t4);
+}
+function _temp2(e) {
+  if (e.type === "generic-error") {
+    return `generic-error:${e.source}:${e.error}`;
+  }
+  return `${e.type}:${e.source}`;
+}
+function _temp() {
+  return isEnvTruthy("true");
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useInterval","getIsRemoteMode","getIsScrollDraining","useNotifications","Text","getInitializationStatus","getLspServerManager","useSetAppState","logForDebugging","isEnvTruthy","LSP_POLL_INTERVAL_MS","useLspInitializationNotification","$","_c","addNotification","setAppState","shouldPoll","setShouldPoll","useState","_temp","t0","Symbol","for","Set","notifiedErrorsRef","useRef","t1","source","errorMessage","errorKey","current","has","add","prev","existingKeys","plugins","errors","map","_temp2","stateErrorKey","type","const","error","displayName","startsWith","split","key","jsx","priority","timeoutMs","addError","t2","status","message","manager","servers","getAllServers","serverName","server","state","lastError","poll","t3","t4","useEffect","e"],"sources":["useLspInitializationNotification.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useInterval } from 'usehooks-ts'\nimport { getIsRemoteMode, getIsScrollDraining } from '../../bootstrap/state.js'\nimport { useNotifications } from '../../context/notifications.js'\nimport { Text } from '../../ink.js'\nimport {\n  getInitializationStatus,\n  getLspServerManager,\n} from '../../services/lsp/manager.js'\nimport { useSetAppState } from '../../state/AppState.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { isEnvTruthy } from '../../utils/envUtils.js'\n\nconst LSP_POLL_INTERVAL_MS = 5000\n\n/**\n * Hook that polls LSP status and shows a notification when:\n * 1. Manager initialization fails\n * 2. Any LSP server enters an error state\n *\n * Also adds errors to appState.plugins.errors for /doctor display.\n *\n * Only active when ENABLE_LSP_TOOL is set.\n */\nexport function useLspInitializationNotification(): void {\n  const { addNotification } = useNotifications()\n  const setAppState = useSetAppState()\n  // Lazy initializer — eager form re-evaluates isEnvTruthy on every REPL\n  // render (the arg expression runs even though useState ignores it after\n  // mount). Showed up as 7.2s isEnvTruthy self-time during PageUp spam\n  // after #24498 swapped cheap !!process.env.X for isEnvTruthy().\n  const [shouldPoll, setShouldPoll] = React.useState(() =>\n    isEnvTruthy(\"true\"),\n  )\n  // Track which errors we've already notified about to avoid duplicates\n  const notifiedErrorsRef = React.useRef<Set<string>>(new Set())\n\n  const addError = React.useCallback(\n    (source: string, errorMessage: string) => {\n      const errorKey = `${source}:${errorMessage}`\n      if (notifiedErrorsRef.current.has(errorKey)) {\n        return // Already notified\n      }\n      notifiedErrorsRef.current.add(errorKey)\n\n      logForDebugging(`LSP error: ${source} - ${errorMessage}`)\n\n      // Add error to appState.plugins.errors\n      setAppState(prev => {\n        // Check if this error already exists to avoid duplicates\n        const existingKeys = new Set(\n          prev.plugins.errors.map(e => {\n            if (e.type === 'generic-error') {\n              return `generic-error:${e.source}:${e.error}`\n            }\n            return `${e.type}:${e.source}`\n          }),\n        )\n\n        const stateErrorKey = `generic-error:${source}:${errorMessage}`\n        if (existingKeys.has(stateErrorKey)) {\n          return prev\n        }\n\n        return {\n          ...prev,\n          plugins: {\n            ...prev.plugins,\n            errors: [\n              ...prev.plugins.errors,\n              {\n                type: 'generic-error' as const,\n                source,\n                error: errorMessage,\n              },\n            ],\n          },\n        }\n      })\n\n      // Show notification - extract plugin name from source like \"plugin:typescript-lsp:typescript\"\n      const displayName = source.startsWith('plugin:')\n        ? (source.split(':')[1] ?? source)\n        : source\n\n      addNotification({\n        key: `lsp-error-${source}`,\n        jsx: (\n          <>\n            <Text color=\"error\">LSP for {displayName} failed</Text>\n            <Text dimColor> · /plugin for details</Text>\n          </>\n        ),\n        priority: 'medium',\n        timeoutMs: 8000,\n      })\n    },\n    [addNotification, setAppState],\n  )\n\n  const poll = React.useCallback(() => {\n    if (getIsRemoteMode()) return\n    // Skip during scroll drain — iterating all LSP servers + setAppState\n    // competes for the event loop with scroll frames. Next interval picks up.\n    if (getIsScrollDraining()) return\n\n    const status = getInitializationStatus()\n\n    // Check manager initialization status\n    if (status.status === 'failed') {\n      addError('lsp-manager', status.error.message)\n      setShouldPoll(false)\n      return\n    }\n\n    if (status.status === 'pending' || status.status === 'not-started') {\n      // Still initializing, continue polling\n      return\n    }\n\n    // Manager initialized successfully - check for server errors\n    const manager = getLspServerManager()\n    if (manager) {\n      const servers = manager.getAllServers()\n      for (const [serverName, server] of servers) {\n        if (server.state === 'error' && server.lastError) {\n          addError(serverName, server.lastError.message)\n        }\n      }\n    }\n    // Continue polling to detect future server errors\n  }, [addError])\n\n  useInterval(poll, shouldPoll ? LSP_POLL_INTERVAL_MS : null)\n\n  // Initial poll on mount\n  React.useEffect(() => {\n    if (getIsRemoteMode() || !shouldPoll) return\n    poll()\n  }, [poll, shouldPoll])\n}\n"],"mappings":"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","ignoreList":[]}

package/src/hooks/notifs/useMcpConnectivityStatus.tsx

@@ -0,0 +1,88 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect } from 'react';
+import { useNotifications } from 'src/context/notifications.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { Text } from '../../ink.js';
+import { hasClaudeAiMcpEverConnected } from '../../services/mcp/claudeai.js';
+import type { MCPServerConnection } from '../../services/mcp/types.js';
+type Props = {
+  mcpClients?: MCPServerConnection[];
+};
+const EMPTY_MCP_CLIENTS: MCPServerConnection[] = [];
+export function useMcpConnectivityStatus(t0) {
+  const $ = _c(4);
+  const {
+    mcpClients: t1
+  } = t0;
+  const mcpClients = t1 === undefined ? EMPTY_MCP_CLIENTS : t1;
+  const {
+    addNotification
+  } = useNotifications();
+  let t2;
+  let t3;
+  if ($[0] !== addNotification || $[1] !== mcpClients) {
+    t2 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      const failedLocalClients = mcpClients.filter(_temp);
+      const failedClaudeAiClients = mcpClients.filter(_temp2);
+      const needsAuthLocalServers = mcpClients.filter(_temp3);
+      const needsAuthClaudeAiServers = mcpClients.filter(_temp4);
+      if (failedLocalClients.length === 0 && failedClaudeAiClients.length === 0 && needsAuthLocalServers.length === 0 && needsAuthClaudeAiServers.length === 0) {
+        return;
+      }
+      if (failedLocalClients.length > 0) {
+        addNotification({
+          key: "mcp-failed",
+          jsx: <><Text color="error">{failedLocalClients.length} MCP{" "}{failedLocalClients.length === 1 ? "server" : "servers"} failed</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+      if (failedClaudeAiClients.length > 0) {
+        addNotification({
+          key: "mcp-claudeai-failed",
+          jsx: <><Text color="error">{failedClaudeAiClients.length} claude.ai{" "}{failedClaudeAiClients.length === 1 ? "connector" : "connectors"}{" "}unavailable</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+      if (needsAuthLocalServers.length > 0) {
+        addNotification({
+          key: "mcp-needs-auth",
+          jsx: <><Text color="warning">{needsAuthLocalServers.length} MCP{" "}{needsAuthLocalServers.length === 1 ? "server needs" : "servers need"}{" "}auth</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+      if (needsAuthClaudeAiServers.length > 0) {
+        addNotification({
+          key: "mcp-claudeai-needs-auth",
+          jsx: <><Text color="warning">{needsAuthClaudeAiServers.length} claude.ai{" "}{needsAuthClaudeAiServers.length === 1 ? "connector needs" : "connectors need"}{" "}auth</Text><Text dimColor={true}> · /mcp</Text></>,
+          priority: "medium"
+        });
+      }
+    };
+    t3 = [addNotification, mcpClients];
+    $[0] = addNotification;
+    $[1] = mcpClients;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t2 = $[2];
+    t3 = $[3];
+  }
+  useEffect(t2, t3);
+}
+function _temp4(client_2) {
+  return client_2.type === "needs-auth" && client_2.config.type === "claudeai-proxy" && hasClaudeAiMcpEverConnected(client_2.name);
+}
+function _temp3(client_1) {
+  return client_1.type === "needs-auth" && client_1.config.type !== "claudeai-proxy";
+}
+function _temp2(client_0) {
+  return client_0.type === "failed" && client_0.config.type === "claudeai-proxy" && hasClaudeAiMcpEverConnected(client_0.name);
+}
+function _temp(client) {
+  return client.type === "failed" && client.config.type !== "sse-ide" && client.config.type !== "ws-ide" && client.config.type !== "claudeai-proxy";
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useNotifications","getIsRemoteMode","Text","hasClaudeAiMcpEverConnected","MCPServerConnection","Props","mcpClients","EMPTY_MCP_CLIENTS","useMcpConnectivityStatus","t0","$","_c","t1","undefined","addNotification","t2","t3","failedLocalClients","filter","_temp","failedClaudeAiClients","_temp2","needsAuthLocalServers","_temp3","needsAuthClaudeAiServers","_temp4","length","key","jsx","priority","client_2","client","type","config","name","client_1","client_0"],"sources":["useMcpConnectivityStatus.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect } from 'react'\nimport { useNotifications } from 'src/context/notifications.js'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\nimport { Text } from '../../ink.js'\nimport { hasClaudeAiMcpEverConnected } from '../../services/mcp/claudeai.js'\nimport type { MCPServerConnection } from '../../services/mcp/types.js'\n\ntype Props = {\n  mcpClients?: MCPServerConnection[]\n}\n\nconst EMPTY_MCP_CLIENTS: MCPServerConnection[] = []\n\nexport function useMcpConnectivityStatus({\n  mcpClients = EMPTY_MCP_CLIENTS,\n}: Props): void {\n  const { addNotification } = useNotifications()\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    const failedLocalClients = mcpClients.filter(\n      client =>\n        client.type === 'failed' &&\n        client.config.type !== 'sse-ide' &&\n        client.config.type !== 'ws-ide' &&\n        client.config.type !== 'claudeai-proxy',\n    )\n    // claude.ai failures get a separate notification: they almost always indicate\n    // a toolbox-service outage (shared auth backend), not a local config issue.\n    // Only flag connectors that have previously connected successfully — an\n    // org-configured connector that's been needs-auth since it appeared is one\n    // the user has ignored and shouldn't nag about; one that was working\n    // yesterday and is now failed is a state change worth surfacing.\n    const failedClaudeAiClients = mcpClients.filter(\n      client =>\n        client.type === 'failed' &&\n        client.config.type === 'claudeai-proxy' &&\n        hasClaudeAiMcpEverConnected(client.name),\n    )\n    const needsAuthLocalServers = mcpClients.filter(\n      client =>\n        client.type === 'needs-auth' && client.config.type !== 'claudeai-proxy',\n    )\n    const needsAuthClaudeAiServers = mcpClients.filter(\n      client =>\n        client.type === 'needs-auth' &&\n        client.config.type === 'claudeai-proxy' &&\n        hasClaudeAiMcpEverConnected(client.name),\n    )\n    if (\n      failedLocalClients.length === 0 &&\n      failedClaudeAiClients.length === 0 &&\n      needsAuthLocalServers.length === 0 &&\n      needsAuthClaudeAiServers.length === 0\n    ) {\n      return\n    }\n    if (failedLocalClients.length > 0) {\n      addNotification({\n        key: 'mcp-failed',\n        jsx: (\n          <>\n            <Text color=\"error\">\n              {failedLocalClients.length} MCP{' '}\n              {failedLocalClients.length === 1 ? 'server' : 'servers'} failed\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n    if (failedClaudeAiClients.length > 0) {\n      addNotification({\n        key: 'mcp-claudeai-failed',\n        jsx: (\n          <>\n            <Text color=\"error\">\n              {failedClaudeAiClients.length} claude.ai{' '}\n              {failedClaudeAiClients.length === 1 ? 'connector' : 'connectors'}{' '}\n              unavailable\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n    if (needsAuthLocalServers.length > 0) {\n      addNotification({\n        key: 'mcp-needs-auth',\n        jsx: (\n          <>\n            <Text color=\"warning\">\n              {needsAuthLocalServers.length} MCP{' '}\n              {needsAuthLocalServers.length === 1\n                ? 'server needs'\n                : 'servers need'}{' '}\n              auth\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n    if (needsAuthClaudeAiServers.length > 0) {\n      addNotification({\n        key: 'mcp-claudeai-needs-auth',\n        jsx: (\n          <>\n            <Text color=\"warning\">\n              {needsAuthClaudeAiServers.length} claude.ai{' '}\n              {needsAuthClaudeAiServers.length === 1\n                ? 'connector needs'\n                : 'connectors need'}{' '}\n              auth\n            </Text>\n            <Text dimColor> · /mcp</Text>\n          </>\n        ),\n        priority: 'medium',\n      })\n    }\n  }, [addNotification, mcpClients])\n}\n"],"mappings":"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","ignoreList":[]}

package/src/hooks/notifs/useModelMigrationNotifications.tsx

@@ -0,0 +1,52 @@
+import type { Notification } from 'src/context/notifications.js';
+import { type GlobalConfig, getGlobalConfig } from 'src/utils/config.js';
+import { useStartupNotification } from './useStartupNotification.js';
+
+// Shows a one-time notification right after a model migration writes its
+// timestamp to config. Each entry reads its own timestamp field(s) and emits
+// a notification if the write happened within the last 3s (i.e. this launch).
+// Future model migrations: add an entry to MIGRATIONS below.
+const MIGRATIONS: ((c: GlobalConfig) => Notification | undefined)[] = [
+// Sonnet 4.5 → 4.6 (pro/max/team premium)
+c => {
+  if (!recent(c.sonnet45To46MigrationTimestamp)) return;
+  return {
+    key: 'sonnet-46-update',
+    text: 'Model updated to Sonnet 4.6',
+    color: 'suggestion',
+    priority: 'high',
+    timeoutMs: 3000
+  };
+},
+// Opus Pro → default, or pinned 4.0/4.1 → opus alias. Both land on the
+// current Opus default (4.6 for 1P).
+c => {
+  const isLegacyRemap = Boolean(c.legacyOpusMigrationTimestamp);
+  const ts = c.legacyOpusMigrationTimestamp ?? c.opusProMigrationTimestamp;
+  if (!recent(ts)) return;
+  return {
+    key: 'opus-pro-update',
+    text: isLegacyRemap ? 'Model updated to Opus 4.6 · Set CLAUDE_CODE_DISABLE_LEGACY_MODEL_REMAP=1 to opt out' : 'Model updated to Opus 4.6',
+    color: 'suggestion',
+    priority: 'high',
+    timeoutMs: isLegacyRemap ? 8000 : 3000
+  };
+}];
+export function useModelMigrationNotifications() {
+  useStartupNotification(_temp);
+}
+function _temp() {
+  const config = getGlobalConfig();
+  const notifs = [];
+  for (const migration of MIGRATIONS) {
+    const notif = migration(config);
+    if (notif) {
+      notifs.push(notif);
+    }
+  }
+  return notifs.length > 0 ? notifs : null;
+}
+function recent(ts: number | undefined): boolean {
+  return ts !== undefined && Date.now() - ts < 3000;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/hooks/notifs/useNpmDeprecationNotification.tsx

@@ -0,0 +1,25 @@
+import { isInBundledMode } from 'src/utils/bundledMode.js';
+import { getCurrentInstallationType } from 'src/utils/doctorDiagnostic.js';
+import { isEnvTruthy } from 'src/utils/envUtils.js';
+import { useStartupNotification } from './useStartupNotification.js';
+const NPM_DEPRECATION_MESSAGE = 'Claude Code has switched from npm to native installer. Run `claude install` or see https://docs.anthropic.com/en/docs/claude-code/getting-started for more options.';
+export function useNpmDeprecationNotification() {
+  useStartupNotification(_temp);
+}
+async function _temp() {
+  if (isInBundledMode() || isEnvTruthy(process.env.DISABLE_INSTALLATION_CHECKS)) {
+    return null;
+  }
+  const installationType = await getCurrentInstallationType();
+  if (installationType === "development") {
+    return null;
+  }
+  return {
+    timeoutMs: 15000,
+    key: "npm-deprecation-warning",
+    text: NPM_DEPRECATION_MESSAGE,
+    color: "warning",
+    priority: "high"
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/hooks/notifs/usePluginAutoupdateNotification.tsx

@@ -0,0 +1,83 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useState } from 'react';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { useNotifications } from '../../context/notifications.js';
+import { Text } from '../../ink.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { onPluginsAutoUpdated } from '../../utils/plugins/pluginAutoupdate.js';
+
+/**
+ * Hook that displays a notification when plugins have been auto-updated.
+ * The notification tells the user to run /reload-plugins to apply the updates.
+ */
+export function usePluginAutoupdateNotification() {
+  const $ = _c(7);
+  const {
+    addNotification
+  } = useNotifications();
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = [];
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  const [updatedPlugins, setUpdatedPlugins] = useState(t0);
+  let t1;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      const unsubscribe = onPluginsAutoUpdated(plugins => {
+        logForDebugging(`Plugin autoupdate notification: ${plugins.length} plugin(s) updated`);
+        setUpdatedPlugins(plugins);
+      });
+      return unsubscribe;
+    };
+    t2 = [];
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  let t4;
+  if ($[3] !== addNotification || $[4] !== updatedPlugins) {
+    t3 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (updatedPlugins.length === 0) {
+        return;
+      }
+      const pluginNames = updatedPlugins.map(_temp);
+      const displayNames = pluginNames.length <= 2 ? pluginNames.join(" and ") : `${pluginNames.length} plugins`;
+      addNotification({
+        key: "plugin-autoupdate-restart",
+        jsx: <><Text color="success">{pluginNames.length === 1 ? "Plugin" : "Plugins"} updated:{" "}{displayNames}</Text><Text dimColor={true}> · Run /reload-plugins to apply</Text></>,
+        priority: "low",
+        timeoutMs: 10000
+      });
+      logForDebugging(`Showing plugin autoupdate notification for: ${pluginNames.join(", ")}`);
+    };
+    t4 = [updatedPlugins, addNotification];
+    $[3] = addNotification;
+    $[4] = updatedPlugins;
+    $[5] = t3;
+    $[6] = t4;
+  } else {
+    t3 = $[5];
+    t4 = $[6];
+  }
+  useEffect(t3, t4);
+}
+function _temp(id) {
+  const atIndex = id.indexOf("@");
+  return atIndex > 0 ? id.substring(0, atIndex) : id;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/hooks/notifs/usePluginInstallationStatus.tsx

@@ -0,0 +1,128 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useMemo } from 'react';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { useNotifications } from '../../context/notifications.js';
+import { Text } from '../../ink.js';
+import { useAppState } from '../../state/AppState.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { plural } from '../../utils/stringUtils.js';
+export function usePluginInstallationStatus() {
+  const $ = _c(20);
+  const {
+    addNotification
+  } = useNotifications();
+  const installationStatus = useAppState(_temp);
+  let t0;
+  bb0: {
+    if (!installationStatus) {
+      let t1;
+      if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+        t1 = {
+          totalFailed: 0,
+          failedMarketplacesCount: 0,
+          failedPluginsCount: 0
+        };
+        $[0] = t1;
+      } else {
+        t1 = $[0];
+      }
+      t0 = t1;
+      break bb0;
+    }
+    let t1;
+    if ($[1] !== installationStatus.marketplaces) {
+      t1 = installationStatus.marketplaces.filter(_temp2);
+      $[1] = installationStatus.marketplaces;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    const failedMarketplaces = t1;
+    let t2;
+    if ($[3] !== installationStatus.plugins) {
+      t2 = installationStatus.plugins.filter(_temp3);
+      $[3] = installationStatus.plugins;
+      $[4] = t2;
+    } else {
+      t2 = $[4];
+    }
+    const failedPlugins = t2;
+    const t3 = failedMarketplaces.length + failedPlugins.length;
+    let t4;
+    if ($[5] !== failedMarketplaces.length || $[6] !== failedPlugins.length || $[7] !== t3) {
+      t4 = {
+        totalFailed: t3,
+        failedMarketplacesCount: failedMarketplaces.length,
+        failedPluginsCount: failedPlugins.length
+      };
+      $[5] = failedMarketplaces.length;
+      $[6] = failedPlugins.length;
+      $[7] = t3;
+      $[8] = t4;
+    } else {
+      t4 = $[8];
+    }
+    t0 = t4;
+  }
+  const {
+    totalFailed,
+    failedMarketplacesCount,
+    failedPluginsCount
+  } = t0;
+  let t1;
+  if ($[9] !== addNotification || $[10] !== failedMarketplacesCount || $[11] !== failedPluginsCount || $[12] !== installationStatus || $[13] !== totalFailed) {
+    t1 = () => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (!installationStatus) {
+        logForDebugging("No installation status to monitor");
+        return;
+      }
+      if (totalFailed === 0) {
+        return;
+      }
+      logForDebugging(`Plugin installation status: ${failedMarketplacesCount} failed marketplaces, ${failedPluginsCount} failed plugins`);
+      if (totalFailed === 0) {
+        return;
+      }
+      logForDebugging(`Adding notification for ${totalFailed} failed installations`);
+      addNotification({
+        key: "plugin-install-failed",
+        jsx: <><Text color="error">{totalFailed} {plural(totalFailed, "plugin")} failed to install</Text><Text dimColor={true}> · /plugin for details</Text></>,
+        priority: "medium"
+      });
+    };
+    $[9] = addNotification;
+    $[10] = failedMarketplacesCount;
+    $[11] = failedPluginsCount;
+    $[12] = installationStatus;
+    $[13] = totalFailed;
+    $[14] = t1;
+  } else {
+    t1 = $[14];
+  }
+  let t2;
+  if ($[15] !== addNotification || $[16] !== failedMarketplacesCount || $[17] !== failedPluginsCount || $[18] !== totalFailed) {
+    t2 = [addNotification, totalFailed, failedMarketplacesCount, failedPluginsCount];
+    $[15] = addNotification;
+    $[16] = failedMarketplacesCount;
+    $[17] = failedPluginsCount;
+    $[18] = totalFailed;
+    $[19] = t2;
+  } else {
+    t2 = $[19];
+  }
+  useEffect(t1, t2);
+}
+function _temp3(p) {
+  return p.status === "failed";
+}
+function _temp2(m) {
+  return m.status === "failed";
+}
+function _temp(s) {
+  return s.plugins.installationStatus;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useMemo","getIsRemoteMode","useNotifications","Text","useAppState","logForDebugging","plural","usePluginInstallationStatus","$","_c","addNotification","installationStatus","_temp","t0","bb0","t1","Symbol","for","totalFailed","failedMarketplacesCount","failedPluginsCount","marketplaces","filter","_temp2","failedMarketplaces","t2","plugins","_temp3","failedPlugins","t3","length","t4","key","jsx","priority","p","status","m","s"],"sources":["usePluginInstallationStatus.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useMemo } from 'react'\nimport { getIsRemoteMode } from '../../bootstrap/state.js'\nimport { useNotifications } from '../../context/notifications.js'\nimport { Text } from '../../ink.js'\nimport { useAppState } from '../../state/AppState.js'\nimport { logForDebugging } from '../../utils/debug.js'\nimport { plural } from '../../utils/stringUtils.js'\n\nexport function usePluginInstallationStatus(): void {\n  const { addNotification } = useNotifications()\n  const installationStatus = useAppState(s => s.plugins.installationStatus)\n\n  // Memoize the failed counts to prevent unnecessary effect triggers\n  const { totalFailed, failedMarketplacesCount, failedPluginsCount } =\n    useMemo(() => {\n      if (!installationStatus) {\n        return {\n          totalFailed: 0,\n          failedMarketplacesCount: 0,\n          failedPluginsCount: 0,\n        }\n      }\n\n      const failedMarketplaces = installationStatus.marketplaces.filter(\n        m => m.status === 'failed',\n      )\n      const failedPlugins = installationStatus.plugins.filter(\n        p => p.status === 'failed',\n      )\n\n      return {\n        totalFailed: failedMarketplaces.length + failedPlugins.length,\n        failedMarketplacesCount: failedMarketplaces.length,\n        failedPluginsCount: failedPlugins.length,\n      }\n    }, [installationStatus])\n\n  useEffect(() => {\n    if (getIsRemoteMode()) return\n    if (!installationStatus) {\n      logForDebugging('No installation status to monitor')\n      return\n    }\n\n    if (totalFailed === 0) {\n      return\n    }\n\n    logForDebugging(\n      `Plugin installation status: ${failedMarketplacesCount} failed marketplaces, ${failedPluginsCount} failed plugins`,\n    )\n\n    if (totalFailed === 0) {\n      return\n    }\n\n    // Add notification for failures\n    logForDebugging(\n      `Adding notification for ${totalFailed} failed installations`,\n    )\n    addNotification({\n      key: 'plugin-install-failed',\n      jsx: (\n        <>\n          <Text color=\"error\">\n            {totalFailed} {plural(totalFailed, 'plugin')} failed to install\n          </Text>\n          <Text dimColor> · /plugin for details</Text>\n        </>\n      ),\n      priority: 'medium',\n    })\n  }, [\n    addNotification,\n    totalFailed,\n    failedMarketplacesCount,\n    failedPluginsCount,\n  ])\n}\n"],"mappings":"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","ignoreList":[]}