@xelauvas/xela-cli 0.1.0

package/src/commands/privacy-settings/privacy-settings.tsx

@@ -0,0 +1,58 @@
+import * as React from 'react';
+import { type GroveDecision, GroveDialog, PrivacySettingsDialog } from '../../components/grove/Grove.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
+import { getGroveNoticeConfig, getGroveSettings, isQualifiedForGrove } from '../../services/api/grove.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+const FALLBACK_MESSAGE = 'Review and manage your privacy settings at https://claude.ai/settings/data-privacy-controls';
+export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode | null> {
+  const qualified = await isQualifiedForGrove();
+  if (!qualified) {
+    onDone(FALLBACK_MESSAGE);
+    return null;
+  }
+  const [settingsResult, configResult] = await Promise.all([getGroveSettings(), getGroveNoticeConfig()]);
+  // Hide dialog on API failure (after retry)
+  if (!settingsResult.success) {
+    onDone(FALLBACK_MESSAGE);
+    return null;
+  }
+  const settings = settingsResult.data;
+  const config = configResult.success ? configResult.data : null;
+  async function onDoneWithDecision(decision: GroveDecision) {
+    if (decision === 'escape' || decision === 'defer') {
+      onDone('Privacy settings dialog dismissed', {
+        display: 'system'
+      });
+      return;
+    }
+    await onDoneWithSettingsCheck();
+  }
+  async function onDoneWithSettingsCheck() {
+    const updatedSettingsResult = await getGroveSettings();
+    if (!updatedSettingsResult.success) {
+      onDone('Unable to retrieve updated privacy settings', {
+        display: 'system'
+      });
+      return;
+    }
+    const updatedSettings = updatedSettingsResult.data;
+    const groveStatus = updatedSettings.grove_enabled ? 'true' : 'false';
+    onDone(`"Help improve Claude" set to ${groveStatus}.`);
+    if (settings.grove_enabled !== null && settings.grove_enabled !== updatedSettings.grove_enabled) {
+      logEvent('tengu_grove_policy_toggled', {
+        state: updatedSettings.grove_enabled as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        location: 'settings' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+    }
+  }
+
+  // Show privacy settings directly if the user has already accepted the
+  // terms.
+  if (settings.grove_enabled !== null) {
+    return <PrivacySettingsDialog settings={settings} domainExcluded={config?.domain_excluded} onDone={onDoneWithSettingsCheck}></PrivacySettingsDialog>;
+  }
+
+  // Show the GroveDialog for users who haven't accepted terms yet
+  return <GroveDialog showIfAlreadyViewed={true} onDone={onDoneWithDecision} location={'settings'} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/commands/rate-limit-options/index.ts

@@ -0,0 +1,19 @@
+import type { Command } from '../../commands.js'
+import { isClaudeAISubscriber } from '../../utils/auth.js'
+
+const rateLimitOptions = {
+  type: 'local-jsx',
+  name: 'rate-limit-options',
+  description: 'Show options when rate limit is reached',
+  isEnabled: () => {
+    if (!isClaudeAISubscriber()) {
+      return false
+    }
+
+    return true
+  },
+  isHidden: true, // Hidden from help - only used internally
+  load: () => import('./rate-limit-options.js'),
+} satisfies Command
+
+export default rateLimitOptions

package/src/commands/rate-limit-options/rate-limit-options.tsx

@@ -0,0 +1,210 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useMemo, useState } from 'react';
+import type { CommandResultDisplay, LocalJSXCommandContext } from '../../commands.js';
+import { type OptionWithDescription, Select } from '../../components/CustomSelect/select.js';
+import { Dialog } from '../../components/design-system/Dialog.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { useClaudeAiLimits } from '../../services/claudeAiLimitsHook.js';
+import type { ToolUseContext } from '../../Tool.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+import { getOauthAccountInfo, getRateLimitTier, getSubscriptionType } from '../../utils/auth.js';
+import { hasClaudeAiBillingAccess } from '../../utils/billing.js';
+import { call as extraUsageCall } from '../extra-usage/extra-usage.js';
+import { extraUsage } from '../extra-usage/index.js';
+import upgrade from '../upgrade/index.js';
+import { call as upgradeCall } from '../upgrade/upgrade.js';
+type RateLimitOptionsMenuOptionType = 'upgrade' | 'extra-usage' | 'cancel';
+type RateLimitOptionsMenuProps = {
+  onDone: (result?: string, options?: {
+    display?: CommandResultDisplay | undefined;
+  } | undefined) => void;
+  context: ToolUseContext & LocalJSXCommandContext;
+};
+function RateLimitOptionsMenu(t0) {
+  const $ = _c(25);
+  const {
+    onDone,
+    context
+  } = t0;
+  const [subCommandJSX, setSubCommandJSX] = useState(null);
+  const claudeAiLimits = useClaudeAiLimits();
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = getSubscriptionType();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const subscriptionType = t1;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = getRateLimitTier();
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const rateLimitTier = t2;
+  const hasExtraUsageEnabled = getOauthAccountInfo()?.hasExtraUsageEnabled === true;
+  const isMax = subscriptionType === "max";
+  const isMax20x = isMax && rateLimitTier === "default_claude_max_20x";
+  const isTeamOrEnterprise = subscriptionType === "team" || subscriptionType === "enterprise";
+  const buyFirst = getFeatureValue_CACHED_MAY_BE_STALE("tengu_jade_anvil_4", false);
+  let t3;
+  bb0: {
+    let actionOptions;
+    if ($[2] !== claudeAiLimits.overageDisabledReason || $[3] !== claudeAiLimits.overageStatus) {
+      actionOptions = [];
+      if (extraUsage.isEnabled()) {
+        const hasBillingAccess = hasClaudeAiBillingAccess();
+        const needsToRequestFromAdmin = isTeamOrEnterprise && !hasBillingAccess;
+        const isOrgSpendCapDepleted = claudeAiLimits.overageDisabledReason === "out_of_credits" || claudeAiLimits.overageDisabledReason === "org_level_disabled_until" || claudeAiLimits.overageDisabledReason === "org_service_zero_credit_limit";
+        if (needsToRequestFromAdmin && isOrgSpendCapDepleted) {} else {
+          const isOverageState = claudeAiLimits.overageStatus === "rejected" || claudeAiLimits.overageStatus === "allowed_warning";
+          let label;
+          if (needsToRequestFromAdmin) {
+            label = isOverageState ? "Request more" : "Request extra usage";
+          } else {
+            label = hasExtraUsageEnabled ? "Add funds to continue with extra usage" : "Switch to extra usage";
+          }
+          let t4;
+          if ($[5] !== label) {
+            t4 = {
+              label,
+              value: "extra-usage"
+            };
+            $[5] = label;
+            $[6] = t4;
+          } else {
+            t4 = $[6];
+          }
+          actionOptions.push(t4);
+        }
+      }
+      if (!isMax20x && !isTeamOrEnterprise && upgrade.isEnabled()) {
+        let t4;
+        if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+          t4 = {
+            label: "Upgrade your plan",
+            value: "upgrade"
+          };
+          $[7] = t4;
+        } else {
+          t4 = $[7];
+        }
+        actionOptions.push(t4);
+      }
+      $[2] = claudeAiLimits.overageDisabledReason;
+      $[3] = claudeAiLimits.overageStatus;
+      $[4] = actionOptions;
+    } else {
+      actionOptions = $[4];
+    }
+    let t4;
+    if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+      t4 = {
+        label: "Stop and wait for limit to reset",
+        value: "cancel"
+      };
+      $[8] = t4;
+    } else {
+      t4 = $[8];
+    }
+    const cancelOption = t4;
+    if (buyFirst) {
+      let t5;
+      if ($[9] !== actionOptions) {
+        t5 = [...actionOptions, cancelOption];
+        $[9] = actionOptions;
+        $[10] = t5;
+      } else {
+        t5 = $[10];
+      }
+      t3 = t5;
+      break bb0;
+    }
+    let t5;
+    if ($[11] !== actionOptions) {
+      t5 = [cancelOption, ...actionOptions];
+      $[11] = actionOptions;
+      $[12] = t5;
+    } else {
+      t5 = $[12];
+    }
+    t3 = t5;
+  }
+  const options = t3;
+  let t4;
+  if ($[13] !== onDone) {
+    t4 = function handleCancel() {
+      logEvent("tengu_rate_limit_options_menu_cancel", {});
+      onDone(undefined, {
+        display: "skip"
+      });
+    };
+    $[13] = onDone;
+    $[14] = t4;
+  } else {
+    t4 = $[14];
+  }
+  const handleCancel = t4;
+  let t5;
+  if ($[15] !== context || $[16] !== handleCancel || $[17] !== onDone) {
+    t5 = function handleSelect(value) {
+      if (value === "upgrade") {
+        logEvent("tengu_rate_limit_options_menu_select_upgrade", {});
+        upgradeCall(onDone, context).then(jsx => {
+          if (jsx) {
+            setSubCommandJSX(jsx);
+          }
+        });
+      } else {
+        if (value === "extra-usage") {
+          logEvent("tengu_rate_limit_options_menu_select_extra_usage", {});
+          extraUsageCall(onDone, context).then(jsx_0 => {
+            if (jsx_0) {
+              setSubCommandJSX(jsx_0);
+            }
+          });
+        } else {
+          if (value === "cancel") {
+            handleCancel();
+          }
+        }
+      }
+    };
+    $[15] = context;
+    $[16] = handleCancel;
+    $[17] = onDone;
+    $[18] = t5;
+  } else {
+    t5 = $[18];
+  }
+  const handleSelect = t5;
+  if (subCommandJSX) {
+    return subCommandJSX;
+  }
+  let t6;
+  if ($[19] !== handleSelect || $[20] !== options) {
+    t6 = <Select options={options} onChange={handleSelect} visibleOptionCount={options.length} />;
+    $[19] = handleSelect;
+    $[20] = options;
+    $[21] = t6;
+  } else {
+    t6 = $[21];
+  }
+  let t7;
+  if ($[22] !== handleCancel || $[23] !== t6) {
+    t7 = <Dialog title="What do you want to do?" onCancel={handleCancel} color="suggestion">{t6}</Dialog>;
+    $[22] = handleCancel;
+    $[23] = t6;
+    $[24] = t7;
+  } else {
+    t7 = $[24];
+  }
+  return t7;
+}
+export async function call(onDone: LocalJSXCommandOnDone, context: ToolUseContext & LocalJSXCommandContext): Promise<React.ReactNode> {
+  return <RateLimitOptionsMenu onDone={onDone} context={context} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","useState","CommandResultDisplay","LocalJSXCommandContext","OptionWithDescription","Select","Dialog","getFeatureValue_CACHED_MAY_BE_STALE","logEvent","useClaudeAiLimits","ToolUseContext","LocalJSXCommandOnDone","getOauthAccountInfo","getRateLimitTier","getSubscriptionType","hasClaudeAiBillingAccess","call","extraUsageCall","extraUsage","upgrade","upgradeCall","RateLimitOptionsMenuOptionType","RateLimitOptionsMenuProps","onDone","result","options","display","context","RateLimitOptionsMenu","t0","$","_c","subCommandJSX","setSubCommandJSX","claudeAiLimits","t1","Symbol","for","subscriptionType","t2","rateLimitTier","hasExtraUsageEnabled","isMax","isMax20x","isTeamOrEnterprise","buyFirst","t3","bb0","actionOptions","overageDisabledReason","overageStatus","isEnabled","hasBillingAccess","needsToRequestFromAdmin","isOrgSpendCapDepleted","isOverageState","label","t4","value","push","cancelOption","t5","handleCancel","undefined","handleSelect","then","jsx","jsx_0","t6","length","t7","Promise","ReactNode"],"sources":["rate-limit-options.tsx"],"sourcesContent":["import React, { useMemo, useState } from 'react'\nimport type {\n  CommandResultDisplay,\n  LocalJSXCommandContext,\n} from '../../commands.js'\nimport {\n  type OptionWithDescription,\n  Select,\n} from '../../components/CustomSelect/select.js'\nimport { Dialog } from '../../components/design-system/Dialog.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js'\nimport { logEvent } from '../../services/analytics/index.js'\nimport { useClaudeAiLimits } from '../../services/claudeAiLimitsHook.js'\nimport type { ToolUseContext } from '../../Tool.js'\nimport type { LocalJSXCommandOnDone } from '../../types/command.js'\nimport {\n  getOauthAccountInfo,\n  getRateLimitTier,\n  getSubscriptionType,\n} from '../../utils/auth.js'\nimport { hasClaudeAiBillingAccess } from '../../utils/billing.js'\nimport { call as extraUsageCall } from '../extra-usage/extra-usage.js'\nimport { extraUsage } from '../extra-usage/index.js'\nimport upgrade from '../upgrade/index.js'\nimport { call as upgradeCall } from '../upgrade/upgrade.js'\n\ntype RateLimitOptionsMenuOptionType = 'upgrade' | 'extra-usage' | 'cancel'\n\ntype RateLimitOptionsMenuProps = {\n  onDone: (\n    result?: string,\n    options?:\n      | {\n          display?: CommandResultDisplay | undefined\n        }\n      | undefined,\n  ) => void\n  context: ToolUseContext & LocalJSXCommandContext\n}\n\nfunction RateLimitOptionsMenu({\n  onDone,\n  context,\n}: RateLimitOptionsMenuProps): React.ReactNode {\n  const [subCommandJSX, setSubCommandJSX] = useState<React.ReactNode>(null)\n  const claudeAiLimits = useClaudeAiLimits()\n  const subscriptionType = getSubscriptionType()\n  const rateLimitTier = getRateLimitTier()\n  const hasExtraUsageEnabled =\n    getOauthAccountInfo()?.hasExtraUsageEnabled === true\n  const isMax = subscriptionType === 'max'\n  const isMax20x = isMax && rateLimitTier === 'default_claude_max_20x'\n  const isTeamOrEnterprise =\n    subscriptionType === 'team' || subscriptionType === 'enterprise'\n  const buyFirst = getFeatureValue_CACHED_MAY_BE_STALE(\n    'tengu_jade_anvil_4',\n    false,\n  )\n\n  const options = useMemo<\n    OptionWithDescription<RateLimitOptionsMenuOptionType>[]\n  >(() => {\n    const actionOptions: OptionWithDescription<RateLimitOptionsMenuOptionType>[] =\n      []\n\n    if (extraUsage.isEnabled()) {\n      const hasBillingAccess = hasClaudeAiBillingAccess()\n      const needsToRequestFromAdmin = isTeamOrEnterprise && !hasBillingAccess\n      // Org spend cap depleted - non-admins can't request more since there's nothing to allocate\n      // - out_of_credits: wallet empty\n      // - org_level_disabled_until: org spend cap hit for the month\n      // - org_service_zero_credit_limit: org service has zero credit limit\n      const isOrgSpendCapDepleted =\n        claudeAiLimits.overageDisabledReason === 'out_of_credits' ||\n        claudeAiLimits.overageDisabledReason === 'org_level_disabled_until' ||\n        claudeAiLimits.overageDisabledReason === 'org_service_zero_credit_limit'\n\n      // Hide for non-admin Team/Enterprise users when org spend cap is depleted\n      if (needsToRequestFromAdmin && isOrgSpendCapDepleted) {\n        // Don't show extra-usage option\n      } else {\n        const isOverageState =\n          claudeAiLimits.overageStatus === 'rejected' ||\n          claudeAiLimits.overageStatus === 'allowed_warning'\n\n        let label: string\n        if (needsToRequestFromAdmin) {\n          label = isOverageState ? 'Request more' : 'Request extra usage'\n        } else {\n          label = hasExtraUsageEnabled\n            ? 'Add funds to continue with extra usage'\n            : 'Switch to extra usage'\n        }\n\n        actionOptions.push({\n          label,\n          value: 'extra-usage',\n        })\n      }\n    }\n\n    if (!isMax20x && !isTeamOrEnterprise && upgrade.isEnabled()) {\n      actionOptions.push({\n        label: 'Upgrade your plan',\n        value: 'upgrade',\n      })\n    }\n\n    const cancelOption: OptionWithDescription<RateLimitOptionsMenuOptionType> =\n      {\n        label: 'Stop and wait for limit to reset',\n        value: 'cancel',\n      }\n\n    if (buyFirst) {\n      return [...actionOptions, cancelOption]\n    }\n    return [cancelOption, ...actionOptions]\n  }, [\n    buyFirst,\n    isMax20x,\n    isTeamOrEnterprise,\n    hasExtraUsageEnabled,\n    claudeAiLimits.overageStatus,\n    claudeAiLimits.overageDisabledReason,\n  ])\n\n  function handleCancel(): void {\n    logEvent('tengu_rate_limit_options_menu_cancel', {})\n    onDone(undefined, { display: 'skip' })\n  }\n\n  function handleSelect(value: RateLimitOptionsMenuOptionType): void {\n    if (value === 'upgrade') {\n      logEvent('tengu_rate_limit_options_menu_select_upgrade', {})\n      void upgradeCall(onDone, context).then(jsx => {\n        if (jsx) {\n          setSubCommandJSX(jsx)\n        }\n      })\n    } else if (value === 'extra-usage') {\n      logEvent('tengu_rate_limit_options_menu_select_extra_usage', {})\n      void extraUsageCall(onDone, context).then(jsx => {\n        if (jsx) {\n          setSubCommandJSX(jsx)\n        }\n      })\n    } else if (value === 'cancel') {\n      handleCancel()\n    }\n  }\n\n  if (subCommandJSX) {\n    return subCommandJSX\n  }\n\n  return (\n    <Dialog\n      title=\"What do you want to do?\"\n      onCancel={handleCancel}\n      color=\"suggestion\"\n    >\n      <Select<RateLimitOptionsMenuOptionType>\n        options={options}\n        onChange={handleSelect}\n        visibleOptionCount={options.length}\n      />\n    </Dialog>\n  )\n}\n\nexport async function call(\n  onDone: LocalJSXCommandOnDone,\n  context: ToolUseContext & LocalJSXCommandContext,\n): Promise<React.ReactNode> {\n  return <RateLimitOptionsMenu onDone={onDone} context={context} />\n}\n"],"mappings":"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","ignoreList":[]}

package/src/commands/release-notes/index.ts

@@ -0,0 +1,11 @@
+import type { Command } from '../../commands.js'
+
+const releaseNotes: Command = {
+  description: 'View release notes',
+  name: 'release-notes',
+  type: 'local',
+  supportsNonInteractive: true,
+  load: () => import('./release-notes.js'),
+}
+
+export default releaseNotes

package/src/commands/release-notes/release-notes.ts

@@ -0,0 +1,50 @@
+import type { LocalCommandResult } from '../../types/command.js'
+import {
+  CHANGELOG_URL,
+  fetchAndStoreChangelog,
+  getAllReleaseNotes,
+  getStoredChangelog,
+} from '../../utils/releaseNotes.js'
+
+function formatReleaseNotes(notes: Array<[string, string[]]>): string {
+  return notes
+    .map(([version, notes]) => {
+      const header = `Version ${version}:`
+      const bulletPoints = notes.map(note => `· ${note}`).join('\n')
+      return `${header}\n${bulletPoints}`
+    })
+    .join('\n\n')
+}
+
+export async function call(): Promise<LocalCommandResult> {
+  // Try to fetch the latest changelog with a 500ms timeout
+  let freshNotes: Array<[string, string[]]> = []
+
+  try {
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      setTimeout(rej => rej(new Error('Timeout')), 500, reject)
+    })
+
+    await Promise.race([fetchAndStoreChangelog(), timeoutPromise])
+    freshNotes = getAllReleaseNotes(await getStoredChangelog())
+  } catch {
+    // Either fetch failed or timed out - just use cached notes
+  }
+
+  // If we have fresh notes from the quick fetch, use those
+  if (freshNotes.length > 0) {
+    return { type: 'text', value: formatReleaseNotes(freshNotes) }
+  }
+
+  // Otherwise check cached notes
+  const cachedNotes = getAllReleaseNotes(await getStoredChangelog())
+  if (cachedNotes.length > 0) {
+    return { type: 'text', value: formatReleaseNotes(cachedNotes) }
+  }
+
+  // Nothing available, show link
+  return {
+    type: 'text',
+    value: `See the full changelog at: ${CHANGELOG_URL}`,
+  }
+}

package/src/commands/reload-plugins/index.ts

@@ -0,0 +1,18 @@
+/**
+ * /reload-plugins — Layer-3 refresh. Applies pending plugin changes to the
+ * running session. Implementation lazy-loaded.
+ */
+import type { Command } from '../../commands.js'
+
+const reloadPlugins = {
+  type: 'local',
+  name: 'reload-plugins',
+  description: 'Activate pending plugin changes in the current session',
+  // SDK callers use query.reloadPlugins() (control request) instead of
+  // sending this as a text prompt — that returns structured data
+  // (commands, agents, plugins, mcpServers) for UI updates.
+  supportsNonInteractive: false,
+  load: () => import('./reload-plugins.js'),
+} satisfies Command
+
+export default reloadPlugins

package/src/commands/reload-plugins/reload-plugins.ts

@@ -0,0 +1,61 @@
+import { feature } from 'bun:bundle'
+import { getIsRemoteMode } from '../../bootstrap/state.js'
+import { redownloadUserSettings } from '../../services/settingsSync/index.js'
+import type { LocalCommandCall } from '../../types/command.js'
+import { isEnvTruthy } from '../../utils/envUtils.js'
+import { refreshActivePlugins } from '../../utils/plugins/refresh.js'
+import { settingsChangeDetector } from '../../utils/settings/changeDetector.js'
+import { plural } from '../../utils/stringUtils.js'
+
+export const call: LocalCommandCall = async (_args, context) => {
+  // CCR: re-pull user settings before the cache sweep so enabledPlugins /
+  // extraKnownMarketplaces pushed from the user's local CLI (settingsSync)
+  // take effect. Non-CCR headless (e.g. vscode SDK subprocess) shares disk
+  // with whoever writes settings — the file watcher delivers changes, no
+  // re-pull needed there.
+  //
+  // Managed settings intentionally NOT re-fetched: it already polls hourly
+  // (POLLING_INTERVAL_MS), and policy enforcement is eventually-consistent
+  // by design (stale-cache fallback on fetch failure). Interactive
+  // /reload-plugins has never re-fetched it either.
+  //
+  // No retries: user-initiated command, one attempt + fail-open. The user
+  // can re-run /reload-plugins to retry. Startup path keeps its retries.
+  if (
+    feature('DOWNLOAD_USER_SETTINGS') &&
+    (isEnvTruthy(process.env.CLAUDE_CODE_REMOTE) || getIsRemoteMode())
+  ) {
+    const applied = await redownloadUserSettings()
+    // applyRemoteEntriesToLocal uses markInternalWrite to suppress the
+    // file watcher (correct for startup, nothing listening yet); fire
+    // notifyChange here so mid-session applySettingsChange runs.
+    if (applied) {
+      settingsChangeDetector.notifyChange('userSettings')
+    }
+  }
+
+  const r = await refreshActivePlugins(context.setAppState)
+
+  const parts = [
+    n(r.enabled_count, 'plugin'),
+    n(r.command_count, 'skill'),
+    n(r.agent_count, 'agent'),
+    n(r.hook_count, 'hook'),
+    // "plugin MCP/LSP" disambiguates from user-config/built-in servers,
+    // which /reload-plugins doesn't touch. Commands/hooks are plugin-only;
+    // agent_count is total agents (incl. built-ins). (gh-31321)
+    n(r.mcp_count, 'plugin MCP server'),
+    n(r.lsp_count, 'plugin LSP server'),
+  ]
+  let msg = `Reloaded: ${parts.join(' · ')}`
+
+  if (r.error_count > 0) {
+    msg += `\n${n(r.error_count, 'error')} during load. Run /doctor for details.`
+  }
+
+  return { type: 'text', value: msg }
+}
+
+function n(count: number, noun: string): string {
+  return `${count} ${plural(count, noun)}`
+}

package/src/commands/remote-env/index.ts

@@ -0,0 +1,15 @@
+import type { Command } from '../../commands.js'
+import { isPolicyAllowed } from '../../services/policyLimits/index.js'
+import { isClaudeAISubscriber } from '../../utils/auth.js'
+
+export default {
+  type: 'local-jsx',
+  name: 'remote-env',
+  description: 'Configure the default remote environment for teleport sessions',
+  isEnabled: () =>
+    isClaudeAISubscriber() && isPolicyAllowed('allow_remote_sessions'),
+  get isHidden() {
+    return !isClaudeAISubscriber() || !isPolicyAllowed('allow_remote_sessions')
+  },
+  load: () => import('./remote-env.js'),
+} satisfies Command

package/src/commands/remote-env/remote-env.tsx

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { RemoteEnvironmentDialog } from '../../components/RemoteEnvironmentDialog.js';
+import type { LocalJSXCommandOnDone } from '../../types/command.js';
+export async function call(onDone: LocalJSXCommandOnDone): Promise<React.ReactNode> {
+  return <RemoteEnvironmentDialog onDone={onDone} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlJlbW90ZUVudmlyb25tZW50RGlhbG9nIiwiTG9jYWxKU1hDb21tYW5kT25Eb25lIiwiY2FsbCIsIm9uRG9uZSIsIlByb21pc2UiLCJSZWFjdE5vZGUiXSwic291cmNlcyI6WyJyZW1vdGUtZW52LnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB7IFJlbW90ZUVudmlyb25tZW50RGlhbG9nIH0gZnJvbSAnLi4vLi4vY29tcG9uZW50cy9SZW1vdGVFbnZpcm9ubWVudERpYWxvZy5qcydcbmltcG9ydCB0eXBlIHsgTG9jYWxKU1hDb21tYW5kT25Eb25lIH0gZnJvbSAnLi4vLi4vdHlwZXMvY29tbWFuZC5qcydcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGNhbGwoXG4gIG9uRG9uZTogTG9jYWxKU1hDb21tYW5kT25Eb25lLFxuKTogUHJvbWlzZTxSZWFjdC5SZWFjdE5vZGU+IHtcbiAgcmV0dXJuIDxSZW1vdGVFbnZpcm9ubWVudERpYWxvZyBvbkRvbmU9e29uRG9uZX0gLz5cbn1cbiJdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLQSxLQUFLLE1BQU0sT0FBTztBQUM5QixTQUFTQyx1QkFBdUIsUUFBUSw2Q0FBNkM7QUFDckYsY0FBY0MscUJBQXFCLFFBQVEsd0JBQXdCO0FBRW5FLE9BQU8sZUFBZUMsSUFBSUEsQ0FDeEJDLE1BQU0sRUFBRUYscUJBQXFCLENBQzlCLEVBQUVHLE9BQU8sQ0FBQ0wsS0FBSyxDQUFDTSxTQUFTLENBQUMsQ0FBQztFQUMxQixPQUFPLENBQUMsdUJBQXVCLENBQUMsTUFBTSxDQUFDLENBQUNGLE1BQU0sQ0FBQyxHQUFHO0FBQ3BEIiwiaWdub3JlTGlzdCI6W119