@xelauvas/xela-cli 0.1.0

package/src/components/LogoV2/AnimatedAsterisk.tsx

@@ -0,0 +1,50 @@
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { TEARDROP_ASTERISK } from '../../constants/figures.js';
+import { Box, Text, useAnimationFrame } from '../../ink.js';
+import { getInitialSettings } from '../../utils/settings/settings.js';
+import { hueToRgb, toRGBColor } from '../Spinner/utils.js';
+const SWEEP_DURATION_MS = 1500;
+const SWEEP_COUNT = 2;
+const TOTAL_ANIMATION_MS = SWEEP_DURATION_MS * SWEEP_COUNT;
+const SETTLED_GREY = toRGBColor({
+  r: 153,
+  g: 153,
+  b: 153
+});
+export function AnimatedAsterisk({
+  char = TEARDROP_ASTERISK
+}: {
+  char?: string;
+}): React.ReactNode {
+  // Read prefersReducedMotion once at mount — no useSettings() subscription,
+  // since that would re-render whenever settings change.
+  const [reducedMotion] = useState(() => getInitialSettings().prefersReducedMotion ?? false);
+  const [done, setDone] = useState(reducedMotion);
+  // useAnimationFrame's clock is shared — capture our start offset so the
+  // sweep always begins at hue 0 regardless of when we mount.
+  const startTimeRef = useRef<number | null>(null);
+  // Wire the ref so useAnimationFrame's viewport-pause kicks in: if the
+  // user submits a message before the sweep finishes, the clock stops
+  // automatically once this row enters scrollback (prevents flicker).
+  const [ref, time] = useAnimationFrame(done ? null : 50);
+  useEffect(() => {
+    if (done) return;
+    const t = setTimeout(setDone, TOTAL_ANIMATION_MS, true);
+    return () => clearTimeout(t);
+  }, [done]);
+  if (done) {
+    return <Box ref={ref}>
+        <Text color={SETTLED_GREY}>{char}</Text>
+      </Box>;
+  }
+  if (startTimeRef.current === null) {
+    startTimeRef.current = time;
+  }
+  const elapsed = time - startTimeRef.current;
+  const hue = elapsed / SWEEP_DURATION_MS * 360 % 360;
+  return <Box ref={ref}>
+      <Text color={toRGBColor(hueToRgb(hue))}>{char}</Text>
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/LogoV2/AnimatedClawd.tsx

@@ -0,0 +1,124 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { Box } from '../../ink.js';
+import { getInitialSettings } from '../../utils/settings/settings.js';
+import { Clawd, type ClawdPose } from './Clawd.js';
+type Frame = {
+  pose: ClawdPose;
+  offset: number;
+};
+
+/** Hold a pose for n frames (60ms each). */
+function hold(pose: ClawdPose, offset: number, frames: number): Frame[] {
+  return Array.from({
+    length: frames
+  }, () => ({
+    pose,
+    offset
+  }));
+}
+
+// Offset semantics: marginTop in a fixed-height-3 container. 0 = normal,
+// 1 = crouched. Container height stays 3 so the layout never shifts; during
+// a crouch (offset=1) Clawd's feet row dips below the container and gets
+// clipped — reads as "ducking below the frame" before springing back up.
+
+// Click animation: crouch, then spring up with both arms raised. Twice.
+const JUMP_WAVE: readonly Frame[] = [...hold('default', 1, 2),
+// crouch
+...hold('arms-up', 0, 3),
+// spring!
+...hold('default', 0, 1), ...hold('default', 1, 2),
+// crouch again
+...hold('arms-up', 0, 3),
+// spring!
+...hold('default', 0, 1)];
+
+// Click animation: glance right, then left, then back.
+const LOOK_AROUND: readonly Frame[] = [...hold('look-right', 0, 5), ...hold('look-left', 0, 5), ...hold('default', 0, 1)];
+const CLICK_ANIMATIONS: readonly (readonly Frame[])[] = [JUMP_WAVE, LOOK_AROUND];
+const IDLE: Frame = {
+  pose: 'default',
+  offset: 0
+};
+const FRAME_MS = 60;
+const incrementFrame = (i: number) => i + 1;
+const CLAWD_HEIGHT = 3;
+
+/**
+ * Clawd with click-triggered animations (crouch-jump with arms up, or
+ * look-around). Container height is fixed at CLAWD_HEIGHT — same footprint
+ * as a bare `<Clawd />` — so the surrounding layout never shifts. During a
+ * crouch only the feet row clips (see comment above). Click only fires when
+ * mouse tracking is enabled (i.e. inside `<AlternateScreen>` / fullscreen);
+ * elsewhere this renders and behaves identically to plain `<Clawd />`.
+ */
+export function AnimatedClawd() {
+  const $ = _c(8);
+  const {
+    pose,
+    bounceOffset,
+    onClick
+  } = useClawdAnimation();
+  let t0;
+  if ($[0] !== pose) {
+    t0 = <Clawd pose={pose} />;
+    $[0] = pose;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  let t1;
+  if ($[2] !== bounceOffset || $[3] !== t0) {
+    t1 = <Box marginTop={bounceOffset} flexShrink={0}>{t0}</Box>;
+    $[2] = bounceOffset;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] !== onClick || $[6] !== t1) {
+    t2 = <Box height={CLAWD_HEIGHT} flexDirection="column" onClick={onClick}>{t1}</Box>;
+    $[5] = onClick;
+    $[6] = t1;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  return t2;
+}
+function useClawdAnimation(): {
+  pose: ClawdPose;
+  bounceOffset: number;
+  onClick: () => void;
+} {
+  // Read once at mount — no useSettings() subscription, since that would
+  // re-render on any settings change.
+  const [reducedMotion] = useState(() => getInitialSettings().prefersReducedMotion ?? false);
+  const [frameIndex, setFrameIndex] = useState(-1);
+  const sequenceRef = useRef<readonly Frame[]>(JUMP_WAVE);
+  const onClick = () => {
+    if (reducedMotion || frameIndex !== -1) return;
+    sequenceRef.current = CLICK_ANIMATIONS[Math.floor(Math.random() * CLICK_ANIMATIONS.length)]!;
+    setFrameIndex(0);
+  };
+  useEffect(() => {
+    if (frameIndex === -1) return;
+    if (frameIndex >= sequenceRef.current.length) {
+      setFrameIndex(-1);
+      return;
+    }
+    const timer = setTimeout(setFrameIndex, FRAME_MS, incrementFrame);
+    return () => clearTimeout(timer);
+  }, [frameIndex]);
+  const seq = sequenceRef.current;
+  const current = frameIndex >= 0 && frameIndex < seq.length ? seq[frameIndex]! : IDLE;
+  return {
+    pose: current.pose,
+    bounceOffset: current.offset,
+    onClick
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useState","Box","getInitialSettings","Clawd","ClawdPose","Frame","pose","offset","hold","frames","Array","from","length","JUMP_WAVE","LOOK_AROUND","CLICK_ANIMATIONS","IDLE","FRAME_MS","incrementFrame","i","CLAWD_HEIGHT","AnimatedClawd","$","_c","bounceOffset","onClick","useClawdAnimation","t0","t1","t2","reducedMotion","prefersReducedMotion","frameIndex","setFrameIndex","sequenceRef","current","Math","floor","random","timer","setTimeout","clearTimeout","seq"],"sources":["AnimatedClawd.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport { Box } from '../../ink.js'\nimport { getInitialSettings } from '../../utils/settings/settings.js'\nimport { Clawd, type ClawdPose } from './Clawd.js'\n\ntype Frame = { pose: ClawdPose; offset: number }\n\n/** Hold a pose for n frames (60ms each). */\nfunction hold(pose: ClawdPose, offset: number, frames: number): Frame[] {\n  return Array.from({ length: frames }, () => ({ pose, offset }))\n}\n\n// Offset semantics: marginTop in a fixed-height-3 container. 0 = normal,\n// 1 = crouched. Container height stays 3 so the layout never shifts; during\n// a crouch (offset=1) Clawd's feet row dips below the container and gets\n// clipped — reads as \"ducking below the frame\" before springing back up.\n\n// Click animation: crouch, then spring up with both arms raised. Twice.\nconst JUMP_WAVE: readonly Frame[] = [\n  ...hold('default', 1, 2), // crouch\n  ...hold('arms-up', 0, 3), // spring!\n  ...hold('default', 0, 1),\n  ...hold('default', 1, 2), // crouch again\n  ...hold('arms-up', 0, 3), // spring!\n  ...hold('default', 0, 1),\n]\n\n// Click animation: glance right, then left, then back.\nconst LOOK_AROUND: readonly Frame[] = [\n  ...hold('look-right', 0, 5),\n  ...hold('look-left', 0, 5),\n  ...hold('default', 0, 1),\n]\n\nconst CLICK_ANIMATIONS: readonly (readonly Frame[])[] = [JUMP_WAVE, LOOK_AROUND]\n\nconst IDLE: Frame = { pose: 'default', offset: 0 }\nconst FRAME_MS = 60\nconst incrementFrame = (i: number) => i + 1\nconst CLAWD_HEIGHT = 3\n\n/**\n * Clawd with click-triggered animations (crouch-jump with arms up, or\n * look-around). Container height is fixed at CLAWD_HEIGHT — same footprint\n * as a bare `<Clawd />` — so the surrounding layout never shifts. During a\n * crouch only the feet row clips (see comment above). Click only fires when\n * mouse tracking is enabled (i.e. inside `<AlternateScreen>` / fullscreen);\n * elsewhere this renders and behaves identically to plain `<Clawd />`.\n */\nexport function AnimatedClawd(): React.ReactNode {\n  const { pose, bounceOffset, onClick } = useClawdAnimation()\n  return (\n    <Box height={CLAWD_HEIGHT} flexDirection=\"column\" onClick={onClick}>\n      <Box marginTop={bounceOffset} flexShrink={0}>\n        <Clawd pose={pose} />\n      </Box>\n    </Box>\n  )\n}\n\nfunction useClawdAnimation(): {\n  pose: ClawdPose\n  bounceOffset: number\n  onClick: () => void\n} {\n  // Read once at mount — no useSettings() subscription, since that would\n  // re-render on any settings change.\n  const [reducedMotion] = useState(\n    () => getInitialSettings().prefersReducedMotion ?? false,\n  )\n  const [frameIndex, setFrameIndex] = useState(-1)\n  const sequenceRef = useRef<readonly Frame[]>(JUMP_WAVE)\n\n  const onClick = () => {\n    if (reducedMotion || frameIndex !== -1) return\n    sequenceRef.current =\n      CLICK_ANIMATIONS[Math.floor(Math.random() * CLICK_ANIMATIONS.length)]!\n    setFrameIndex(0)\n  }\n\n  useEffect(() => {\n    if (frameIndex === -1) return\n    if (frameIndex >= sequenceRef.current.length) {\n      setFrameIndex(-1)\n      return\n    }\n    const timer = setTimeout(setFrameIndex, FRAME_MS, incrementFrame)\n    return () => clearTimeout(timer)\n  }, [frameIndex])\n\n  const seq = sequenceRef.current\n  const current =\n    frameIndex >= 0 && frameIndex < seq.length ? seq[frameIndex]! : IDLE\n  return { pose: current.pose, bounceOffset: current.offset, onClick }\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/LogoV2/ChannelsNotice.tsx

@@ -0,0 +1,266 @@
+import { c as _c } from "react/compiler-runtime";
+// Conditionally require()'d in LogoV2.tsx behind feature('KAIROS') ||
+// feature('KAIROS_CHANNELS'). No feature() guard here — the whole file
+// tree-shakes via the require pattern when both flags are false (see
+// docs/feature-gating.md). Do NOT import this module statically from
+// unguarded code.
+
+import * as React from 'react';
+import { useState } from 'react';
+import { type ChannelEntry, getAllowedChannels, getHasDevChannels } from '../../bootstrap/state.js';
+import { Box, Text } from '../../ink.js';
+import { isChannelsEnabled } from '../../services/mcp/channelAllowlist.js';
+import { getEffectiveChannelAllowlist } from '../../services/mcp/channelNotification.js';
+import { getMcpConfigsByScope } from '../../services/mcp/config.js';
+import { getClaudeAIOAuthTokens, getSubscriptionType } from '../../utils/auth.js';
+import { loadInstalledPluginsV2 } from '../../utils/plugins/installedPluginsManager.js';
+import { getSettingsForSource } from '../../utils/settings/settings.js';
+export function ChannelsNotice() {
+  const $ = _c(32);
+  const [t0] = useState(_temp);
+  const {
+    channels,
+    disabled,
+    noAuth,
+    policyBlocked,
+    list,
+    unmatched
+  } = t0;
+  if (channels.length === 0) {
+    return null;
+  }
+  const hasNonDev = channels.some(_temp2);
+  const flag = getHasDevChannels() && hasNonDev ? "Channels" : getHasDevChannels() ? "--dangerously-load-development-channels" : "--channels";
+  if (disabled) {
+    let t1;
+    if ($[0] !== flag || $[1] !== list) {
+      t1 = <Text color="error">{flag} ignored ({list})</Text>;
+      $[0] = flag;
+      $[1] = list;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    let t2;
+    if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+      t2 = <Text dimColor={true}>Channels are not currently available</Text>;
+      $[3] = t2;
+    } else {
+      t2 = $[3];
+    }
+    let t3;
+    if ($[4] !== t1) {
+      t3 = <Box paddingLeft={2} flexDirection="column">{t1}{t2}</Box>;
+      $[4] = t1;
+      $[5] = t3;
+    } else {
+      t3 = $[5];
+    }
+    return t3;
+  }
+  if (noAuth) {
+    let t1;
+    if ($[6] !== flag || $[7] !== list) {
+      t1 = <Text color="error">{flag} ignored ({list})</Text>;
+      $[6] = flag;
+      $[7] = list;
+      $[8] = t1;
+    } else {
+      t1 = $[8];
+    }
+    let t2;
+    if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+      t2 = <Text dimColor={true}>Channels require claude.ai authentication · run /login, then restart</Text>;
+      $[9] = t2;
+    } else {
+      t2 = $[9];
+    }
+    let t3;
+    if ($[10] !== t1) {
+      t3 = <Box paddingLeft={2} flexDirection="column">{t1}{t2}</Box>;
+      $[10] = t1;
+      $[11] = t3;
+    } else {
+      t3 = $[11];
+    }
+    return t3;
+  }
+  if (policyBlocked) {
+    let t1;
+    if ($[12] !== flag || $[13] !== list) {
+      t1 = <Text color="error">{flag} blocked by org policy ({list})</Text>;
+      $[12] = flag;
+      $[13] = list;
+      $[14] = t1;
+    } else {
+      t1 = $[14];
+    }
+    let t2;
+    let t3;
+    if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+      t2 = <Text dimColor={true}>Inbound messages will be silently dropped</Text>;
+      t3 = <Text dimColor={true}>Have an administrator set channelsEnabled: true in managed settings to enable</Text>;
+      $[15] = t2;
+      $[16] = t3;
+    } else {
+      t2 = $[15];
+      t3 = $[16];
+    }
+    let t4;
+    if ($[17] !== unmatched) {
+      t4 = unmatched.map(_temp3);
+      $[17] = unmatched;
+      $[18] = t4;
+    } else {
+      t4 = $[18];
+    }
+    let t5;
+    if ($[19] !== t1 || $[20] !== t4) {
+      t5 = <Box paddingLeft={2} flexDirection="column">{t1}{t2}{t3}{t4}</Box>;
+      $[19] = t1;
+      $[20] = t4;
+      $[21] = t5;
+    } else {
+      t5 = $[21];
+    }
+    return t5;
+  }
+  let t1;
+  if ($[22] !== list) {
+    t1 = <Text color="error">Listening for channel messages from: {list}</Text>;
+    $[22] = list;
+    $[23] = t1;
+  } else {
+    t1 = $[23];
+  }
+  let t2;
+  if ($[24] !== flag) {
+    t2 = <Text dimColor={true}>Experimental · inbound messages will be pushed into this session, this carries prompt injection risks. Restart Claude Code without {flag} to disable.</Text>;
+    $[24] = flag;
+    $[25] = t2;
+  } else {
+    t2 = $[25];
+  }
+  let t3;
+  if ($[26] !== unmatched) {
+    t3 = unmatched.map(_temp4);
+    $[26] = unmatched;
+    $[27] = t3;
+  } else {
+    t3 = $[27];
+  }
+  let t4;
+  if ($[28] !== t1 || $[29] !== t2 || $[30] !== t3) {
+    t4 = <Box paddingLeft={2} flexDirection="column">{t1}{t2}{t3}</Box>;
+    $[28] = t1;
+    $[29] = t2;
+    $[30] = t3;
+    $[31] = t4;
+  } else {
+    t4 = $[31];
+  }
+  return t4;
+}
+function _temp4(u_0) {
+  return <Text key={`${formatEntry(u_0.entry)}:${u_0.why}`} color="warning">{formatEntry(u_0.entry)} · {u_0.why}</Text>;
+}
+function _temp3(u) {
+  return <Text key={`${formatEntry(u.entry)}:${u.why}`} color="warning">{formatEntry(u.entry)} · {u.why}</Text>;
+}
+function _temp2(c) {
+  return !c.dev;
+}
+function _temp() {
+  const ch = getAllowedChannels();
+  if (ch.length === 0) {
+    return {
+      channels: ch,
+      disabled: false,
+      noAuth: false,
+      policyBlocked: false,
+      list: "",
+      unmatched: [] as Unmatched[]
+    };
+  }
+  const l = ch.map(formatEntry).join(", ");
+  const sub = getSubscriptionType();
+  const managed = sub === "team" || sub === "enterprise";
+  const policy = getSettingsForSource("policySettings");
+  const allowlist = getEffectiveChannelAllowlist(sub, policy?.allowedChannelPlugins);
+  return {
+    channels: ch,
+    disabled: !isChannelsEnabled(),
+    noAuth: !getClaudeAIOAuthTokens()?.accessToken,
+    policyBlocked: managed && policy?.channelsEnabled !== true,
+    list: l,
+    unmatched: findUnmatched(ch, allowlist)
+  };
+}
+function formatEntry(c: ChannelEntry): string {
+  return c.kind === 'plugin' ? `plugin:${c.name}@${c.marketplace}` : `server:${c.name}`;
+}
+type Unmatched = {
+  entry: ChannelEntry;
+  why: string;
+};
+function findUnmatched(entries: readonly ChannelEntry[], allowlist: ReturnType<typeof getEffectiveChannelAllowlist>): Unmatched[] {
+  // Server-kind: build one Set from all scopes up front. getMcpConfigsByScope
+  // is not cached (project scope walks the dir tree); getMcpConfigByName would
+  // redo that walk per entry.
+  const scopes = ['enterprise', 'user', 'project', 'local'] as const;
+  const configured = new Set<string>();
+  for (const scope of scopes) {
+    for (const name of Object.keys(getMcpConfigsByScope(scope).servers)) {
+      configured.add(name);
+    }
+  }
+
+  // Plugin-kind installed check: installed_plugins.json keys are
+  // `name@marketplace`. loadInstalledPluginsV2 is cached.
+  const installedPluginIds = new Set(Object.keys(loadInstalledPluginsV2().plugins));
+
+  // Plugin-kind allowlist check: same {marketplace, plugin} test as the
+  // gate at channelNotification.ts. entry.dev bypasses (dev flag opts out
+  // of the allowlist). Org list replaces ledger when set (team/enterprise).
+  // GrowthBook _CACHED_MAY_BE_STALE — cold cache yields [] so every plugin
+  // entry warns; same tradeoff the gate already accepts.
+  const {
+    entries: allowed,
+    source
+  } = allowlist;
+
+  // Independent ifs — a plugin entry that's both uninstalled AND
+  // unlisted shows two lines. Server kind checks config + dev flag.
+  const out: Unmatched[] = [];
+  for (const entry of entries) {
+    if (entry.kind === 'server') {
+      if (!configured.has(entry.name)) {
+        out.push({
+          entry,
+          why: 'no MCP server configured with that name'
+        });
+      }
+      if (!entry.dev) {
+        out.push({
+          entry,
+          why: 'server: entries need --dangerously-load-development-channels'
+        });
+      }
+      continue;
+    }
+    if (!installedPluginIds.has(`${entry.name}@${entry.marketplace}`)) {
+      out.push({
+        entry,
+        why: 'plugin not installed'
+      });
+    }
+    if (!entry.dev && !allowed.some(e => e.plugin === entry.name && e.marketplace === entry.marketplace)) {
+      out.push({
+        entry,
+        why: source === 'org' ? "not on your org's approved channels list" : 'not on the approved channels allowlist'
+      });
+    }
+  }
+  return out;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","ChannelEntry","getAllowedChannels","getHasDevChannels","Box","Text","isChannelsEnabled","getEffectiveChannelAllowlist","getMcpConfigsByScope","getClaudeAIOAuthTokens","getSubscriptionType","loadInstalledPluginsV2","getSettingsForSource","ChannelsNotice","$","_c","t0","_temp","channels","disabled","noAuth","policyBlocked","list","unmatched","length","hasNonDev","some","_temp2","flag","t1","t2","Symbol","for","t3","t4","map","_temp3","t5","_temp4","u_0","formatEntry","u","entry","why","c","dev","ch","Unmatched","l","join","sub","managed","policy","allowlist","allowedChannelPlugins","accessToken","channelsEnabled","findUnmatched","kind","name","marketplace","entries","ReturnType","scopes","const","configured","Set","scope","Object","keys","servers","add","installedPluginIds","plugins","allowed","source","out","has","push","e","plugin"],"sources":["ChannelsNotice.tsx"],"sourcesContent":["// Conditionally require()'d in LogoV2.tsx behind feature('KAIROS') ||\n// feature('KAIROS_CHANNELS'). No feature() guard here — the whole file\n// tree-shakes via the require pattern when both flags are false (see\n// docs/feature-gating.md). Do NOT import this module statically from\n// unguarded code.\n\nimport * as React from 'react'\nimport { useState } from 'react'\nimport {\n  type ChannelEntry,\n  getAllowedChannels,\n  getHasDevChannels,\n} from '../../bootstrap/state.js'\nimport { Box, Text } from '../../ink.js'\nimport { isChannelsEnabled } from '../../services/mcp/channelAllowlist.js'\nimport { getEffectiveChannelAllowlist } from '../../services/mcp/channelNotification.js'\nimport { getMcpConfigsByScope } from '../../services/mcp/config.js'\nimport {\n  getClaudeAIOAuthTokens,\n  getSubscriptionType,\n} from '../../utils/auth.js'\nimport { loadInstalledPluginsV2 } from '../../utils/plugins/installedPluginsManager.js'\nimport { getSettingsForSource } from '../../utils/settings/settings.js'\n\nexport function ChannelsNotice(): React.ReactNode {\n  // Snapshot all reads at mount. This notice enters scrollback immediately\n  // after the logo; any re-render past that point forces a full terminal\n  // reset. getAllowedChannels (bootstrap state), getSettingsForSource\n  // (session cache updated by background polling / /login), and\n  // isChannelsEnabled (GrowthBook 5-min refresh) must be captured once\n  // so a later re-render cannot flip branches.\n  const [{ channels, disabled, noAuth, policyBlocked, list, unmatched }] =\n    useState(() => {\n      const ch = getAllowedChannels()\n      if (ch.length === 0)\n        return {\n          channels: ch,\n          disabled: false,\n          noAuth: false,\n          policyBlocked: false,\n          list: '',\n          unmatched: [] as Unmatched[],\n        }\n      const l = ch.map(formatEntry).join(', ')\n      const sub = getSubscriptionType()\n      const managed = sub === 'team' || sub === 'enterprise'\n      const policy = getSettingsForSource('policySettings')\n      const allowlist = getEffectiveChannelAllowlist(\n        sub,\n        policy?.allowedChannelPlugins,\n      )\n      return {\n        channels: ch,\n        disabled: !isChannelsEnabled(),\n        noAuth: !getClaudeAIOAuthTokens()?.accessToken,\n        policyBlocked: managed && policy?.channelsEnabled !== true,\n        list: l,\n        unmatched: findUnmatched(ch, allowlist),\n      }\n    })\n  if (channels.length === 0) return null\n\n  // When both flags are passed, the list mixes entries and a single flag\n  // name would be wrong for half of it. entry.dev distinguishes origin.\n  const hasNonDev = channels.some(c => !c.dev)\n  const flag =\n    getHasDevChannels() && hasNonDev\n      ? 'Channels'\n      : getHasDevChannels()\n        ? '--dangerously-load-development-channels'\n        : '--channels'\n\n  if (disabled) {\n    return (\n      <Box paddingLeft={2} flexDirection=\"column\">\n        <Text color=\"error\">\n          {flag} ignored ({list})\n        </Text>\n        <Text dimColor>Channels are not currently available</Text>\n      </Box>\n    )\n  }\n\n  if (noAuth) {\n    return (\n      <Box paddingLeft={2} flexDirection=\"column\">\n        <Text color=\"error\">\n          {flag} ignored ({list})\n        </Text>\n        <Text dimColor>\n          Channels require claude.ai authentication · run /login, then restart\n        </Text>\n      </Box>\n    )\n  }\n\n  if (policyBlocked) {\n    return (\n      <Box paddingLeft={2} flexDirection=\"column\">\n        <Text color=\"error\">\n          {flag} blocked by org policy ({list})\n        </Text>\n        <Text dimColor>Inbound messages will be silently dropped</Text>\n        <Text dimColor>\n          Have an administrator set channelsEnabled: true in managed settings to\n          enable\n        </Text>\n        {unmatched.map(u => (\n          <Text key={`${formatEntry(u.entry)}:${u.why}`} color=\"warning\">\n            {formatEntry(u.entry)} · {u.why}\n          </Text>\n        ))}\n      </Box>\n    )\n  }\n\n  // \"Listening for\" not \"active\" — at this point we only know the allowlist\n  // was set. Server connection, capability declaration, and whether the name\n  // even matches a configured MCP server are all still unknown.\n  return (\n    <Box paddingLeft={2} flexDirection=\"column\">\n      <Text color=\"error\">Listening for channel messages from: {list}</Text>\n      <Text dimColor>\n        Experimental · inbound messages will be pushed into this session, this\n        carries prompt injection risks. Restart Claude Code without {flag} to\n        disable.\n      </Text>\n      {unmatched.map(u => (\n        <Text key={`${formatEntry(u.entry)}:${u.why}`} color=\"warning\">\n          {formatEntry(u.entry)} · {u.why}\n        </Text>\n      ))}\n    </Box>\n  )\n}\n\nfunction formatEntry(c: ChannelEntry): string {\n  return c.kind === 'plugin'\n    ? `plugin:${c.name}@${c.marketplace}`\n    : `server:${c.name}`\n}\n\ntype Unmatched = { entry: ChannelEntry; why: string }\n\nfunction findUnmatched(\n  entries: readonly ChannelEntry[],\n  allowlist: ReturnType<typeof getEffectiveChannelAllowlist>,\n): Unmatched[] {\n  // Server-kind: build one Set from all scopes up front. getMcpConfigsByScope\n  // is not cached (project scope walks the dir tree); getMcpConfigByName would\n  // redo that walk per entry.\n  const scopes = ['enterprise', 'user', 'project', 'local'] as const\n  const configured = new Set<string>()\n  for (const scope of scopes) {\n    for (const name of Object.keys(getMcpConfigsByScope(scope).servers)) {\n      configured.add(name)\n    }\n  }\n\n  // Plugin-kind installed check: installed_plugins.json keys are\n  // `name@marketplace`. loadInstalledPluginsV2 is cached.\n  const installedPluginIds = new Set(\n    Object.keys(loadInstalledPluginsV2().plugins),\n  )\n\n  // Plugin-kind allowlist check: same {marketplace, plugin} test as the\n  // gate at channelNotification.ts. entry.dev bypasses (dev flag opts out\n  // of the allowlist). Org list replaces ledger when set (team/enterprise).\n  // GrowthBook _CACHED_MAY_BE_STALE — cold cache yields [] so every plugin\n  // entry warns; same tradeoff the gate already accepts.\n  const { entries: allowed, source } = allowlist\n\n  // Independent ifs — a plugin entry that's both uninstalled AND\n  // unlisted shows two lines. Server kind checks config + dev flag.\n  const out: Unmatched[] = []\n  for (const entry of entries) {\n    if (entry.kind === 'server') {\n      if (!configured.has(entry.name)) {\n        out.push({ entry, why: 'no MCP server configured with that name' })\n      }\n      if (!entry.dev) {\n        out.push({\n          entry,\n          why: 'server: entries need --dangerously-load-development-channels',\n        })\n      }\n      continue\n    }\n    if (!installedPluginIds.has(`${entry.name}@${entry.marketplace}`)) {\n      out.push({ entry, why: 'plugin not installed' })\n    }\n    if (\n      !entry.dev &&\n      !allowed.some(\n        e => e.plugin === entry.name && e.marketplace === entry.marketplace,\n      )\n    ) {\n      out.push({\n        entry,\n        why:\n          source === 'org'\n            ? \"not on your org's approved channels list\"\n            : 'not on the approved channels allowlist',\n      })\n    }\n  }\n  return out\n}\n"],"mappings":"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","ignoreList":[]}