@mseep/claudian 2.0.25

package/src/providers/claude/ui/ClaudeChatUIConfig.ts

@@ -0,0 +1,113 @@
+import type {
+  ProviderChatUIConfig,
+  ProviderPermissionModeToggleConfig,
+  ProviderReasoningOption,
+  ProviderUIOption,
+} from '../../../core/providers/types';
+import { CLAUDE_PROVIDER_ICON } from '../../../shared/icons';
+import { getCustomModelIds } from '../env/claudeModelEnv';
+import { getClaudeModelOptions } from '../modelOptions';
+import { toClaudeRuntimeModelId } from '../modelSelection';
+import { getClaudeProviderSettings, updateClaudeProviderSettings } from '../settings';
+import {
+  DEFAULT_CLAUDE_MODELS,
+  DEFAULT_EFFORT_LEVEL,
+  EFFORT_LEVELS,
+  getContextWindowSize,
+  normalizeEffortLevel,
+  normalizeVisibleModelVariant,
+  supportsXHighEffort,
+} from '../types/models';
+
+const CLAUDE_PERMISSION_MODE_TOGGLE: ProviderPermissionModeToggleConfig = {
+  inactiveValue: 'normal',
+  inactiveLabel: 'Safe',
+  activeValue: 'yolo',
+  activeLabel: 'YOLO',
+  planValue: 'plan',
+  planLabel: 'PLAN',
+};
+
+export const claudeChatUIConfig: ProviderChatUIConfig = {
+  getModelOptions(settings) {
+    return getClaudeModelOptions(settings);
+  },
+
+  ownsModel(model: string, settings: Record<string, unknown>): boolean {
+    const runtimeModel = toClaudeRuntimeModelId(model);
+    return getClaudeModelOptions(settings).some((option: ProviderUIOption) =>
+      option.value === model || toClaudeRuntimeModelId(option.value) === runtimeModel
+    );
+  },
+
+  isAdaptiveReasoningModel(_model: string, _settings: Record<string, unknown>): boolean {
+    return true;
+  },
+
+  getReasoningOptions(model: string, _settings: Record<string, unknown>): ProviderReasoningOption[] {
+    const runtimeModel = toClaudeRuntimeModelId(model);
+    const levels = supportsXHighEffort(runtimeModel)
+      ? EFFORT_LEVELS
+      : EFFORT_LEVELS.filter(e => e.value !== 'xhigh');
+    return levels.map(e => ({ value: e.value, label: e.label }));
+  },
+
+  getDefaultReasoningValue(model: string, _settings: Record<string, unknown>): string {
+    return DEFAULT_EFFORT_LEVEL[toClaudeRuntimeModelId(model)] ?? 'high';
+  },
+
+  getContextWindowSize(model: string, customLimits?: Record<string, number>): number {
+    return getContextWindowSize(toClaudeRuntimeModelId(model), customLimits);
+  },
+
+  isDefaultModel(model: string): boolean {
+    const runtimeModel = toClaudeRuntimeModelId(model);
+    return DEFAULT_CLAUDE_MODELS.some(m => m.value === runtimeModel);
+  },
+
+  applyModelDefaults(model: string, settings: unknown): void {
+    const target = settings as Record<string, unknown>;
+
+    const runtimeModel = toClaudeRuntimeModelId(model);
+    if (DEFAULT_CLAUDE_MODELS.some(m => m.value === runtimeModel)) {
+      target.effortLevel = DEFAULT_EFFORT_LEVEL[runtimeModel] ?? 'high';
+      updateClaudeProviderSettings(target, { lastModel: runtimeModel });
+    } else {
+      target.lastCustomModel = model;
+      target.effortLevel = normalizeEffortLevel(runtimeModel, target.effortLevel);
+    }
+  },
+
+  normalizeModelVariant(model: string, settings) {
+    const claudeSettings = getClaudeProviderSettings(settings);
+    const normalizedRuntimeModel = normalizeVisibleModelVariant(
+      toClaudeRuntimeModelId(model),
+      claudeSettings.enableOpus1M,
+      claudeSettings.enableSonnet1M,
+    );
+    const option = getClaudeModelOptions(settings).find(candidate =>
+      candidate.value === normalizedRuntimeModel
+      || toClaudeRuntimeModelId(candidate.value) === normalizedRuntimeModel
+    );
+    return option?.value ?? normalizedRuntimeModel;
+  },
+
+  getCustomModelIds(envVars: Record<string, string>): Set<string> {
+    return getCustomModelIds(envVars);
+  },
+
+  getPermissionModeToggle() {
+    return CLAUDE_PERMISSION_MODE_TOGGLE;
+  },
+
+  isBangBashEnabled(settings) {
+    return getClaudeProviderSettings(settings).enableBangBash;
+  },
+
+  getProviderIcon() {
+    return CLAUDE_PROVIDER_ICON;
+  },
+};
+
+/** Re-export for type-only use in provider registration. */
+export type { ProviderUIOption };

package/src/providers/claude/ui/ClaudeSettingsTab.ts

@@ -0,0 +1,407 @@
+import * as fs from 'fs';
+import { Setting } from 'obsidian';
+
+import { ProviderSettingsCoordinator } from '../../../core/providers/ProviderSettingsCoordinator';
+import type { ProviderSettingsTabRenderer } from '../../../core/providers/types';
+import { renderEnvironmentSettingsSection } from '../../../features/settings/ui/EnvironmentSettingsSection';
+import { McpSettingsManager } from '../../../features/settings/ui/McpSettingsManager';
+import { t } from '../../../i18n/i18n';
+import { getHostnameKey } from '../../../utils/env';
+import { expandHomePath } from '../../../utils/path';
+import { getClaudeWorkspaceServices } from '../app/ClaudeWorkspaceServices';
+import { resolveClaudeModelSelection } from '../modelOptions';
+import {
+  CLAUDE_SAFE_MODES,
+  type ClaudeSafeMode,
+  getClaudeProviderSettings,
+  updateClaudeProviderSettings,
+} from '../settings';
+import { AgentSettings } from './AgentSettings';
+import { claudeChatUIConfig } from './ClaudeChatUIConfig';
+import { PluginSettingsManager } from './PluginSettingsManager';
+import { SlashCommandSettings } from './SlashCommandSettings';
+
+export const claudeSettingsTabRenderer: ProviderSettingsTabRenderer = {
+  render(container, context) {
+    const claudeWorkspace = getClaudeWorkspaceServices();
+    const settingsBag = context.plugin.settings as unknown as Record<string, unknown>;
+    const claudeSettings = getClaudeProviderSettings(settingsBag);
+
+    const reconcileActiveClaudeModelSelection = (): void => {
+      const activeProvider = settingsBag.settingsProvider;
+      if (activeProvider !== undefined && activeProvider !== 'claude') {
+        return;
+      }
+
+      const currentModel = typeof settingsBag.model === 'string' ? settingsBag.model : '';
+      const nextModel = resolveClaudeModelSelection(settingsBag, currentModel);
+      if (!nextModel || nextModel === currentModel) {
+        return;
+      }
+
+      settingsBag.model = nextModel;
+      claudeChatUIConfig.applyModelDefaults(nextModel, settingsBag);
+    };
+
+    // --- Setup ---
+
+    new Setting(container).setName(t('settings.setup')).setHeading();
+
+    const hostnameKey = getHostnameKey();
+    const platformDesc = process.platform === 'win32'
+      ? t('settings.cliPath.descWindows')
+      : t('settings.cliPath.descUnix');
+    const cliPathDescription = `${t('settings.cliPath.desc')} ${platformDesc}`;
+
+    const cliPathSetting = new Setting(container)
+      .setName(t('settings.cliPath.name'))
+      .setDesc(cliPathDescription);
+
+    const validationEl = container.createDiv({
+      cls: 'claudian-cli-path-validation claudian-setting-validation claudian-setting-validation-error claudian-hidden',
+    });
+
+    const validatePath = (value: string): string | null => {
+      const trimmed = value.trim();
+      if (!trimmed) return null;
+
+      const expandedPath = expandHomePath(trimmed);
+
+      if (!fs.existsSync(expandedPath)) {
+        return t('settings.cliPath.validation.notExist');
+      }
+      const stat = fs.statSync(expandedPath);
+      if (!stat.isFile()) {
+        return t('settings.cliPath.validation.isDirectory');
+      }
+      return null;
+    };
+
+    const updateCliPathValidation = (value: string, inputEl?: HTMLInputElement): boolean => {
+      const error = validatePath(value);
+      if (error) {
+        validationEl.setText(error);
+        validationEl.toggleClass('claudian-hidden', false);
+        if (inputEl) {
+          inputEl.toggleClass('claudian-input-error', true);
+        }
+        return false;
+      }
+
+      validationEl.toggleClass('claudian-hidden', true);
+      if (inputEl) {
+        inputEl.toggleClass('claudian-input-error', false);
+      }
+      return true;
+    };
+
+    const currentValue = claudeSettings.cliPathsByHost[hostnameKey] || '';
+    const cliPathsByHost = { ...claudeSettings.cliPathsByHost };
+    let cliPathInputEl: HTMLInputElement | null = null;
+
+    const persistCliPath = async (value: string): Promise<boolean> => {
+      const isValid = updateCliPathValidation(value, cliPathInputEl ?? undefined);
+      if (!isValid) {
+        return false;
+      }
+
+      const trimmed = value.trim();
+      if (trimmed) {
+        cliPathsByHost[hostnameKey] = trimmed;
+      } else {
+        delete cliPathsByHost[hostnameKey];
+      }
+
+      updateClaudeProviderSettings(settingsBag, { cliPathsByHost: { ...cliPathsByHost } });
+      await context.plugin.saveSettings();
+      claudeWorkspace.cliResolver.reset();
+      const view = context.plugin.getView();
+      await view?.getTabManager()?.broadcastToAllTabs(
+        (service) => Promise.resolve(service.cleanup())
+      );
+      return true;
+    };
+
+    cliPathSetting.addText((text) => {
+      const placeholder = process.platform === 'win32'
+        ? 'D:\\nodejs\\node_global\\node_modules\\@anthropic-ai\\claude-code\\cli-wrapper.cjs'
+        : '/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli-wrapper.cjs';
+
+      text
+        .setPlaceholder(placeholder)
+        .setValue(currentValue)
+        .onChange(async (value) => {
+          await persistCliPath(value);
+        });
+      text.inputEl.addClass('claudian-settings-cli-path-input');
+      cliPathInputEl = text.inputEl;
+
+      updateCliPathValidation(currentValue, text.inputEl);
+    });
+
+    // --- Safety ---
+
+    new Setting(container).setName(t('settings.safety')).setHeading();
+
+    new Setting(container)
+      .setName(t('settings.claudeSafeMode.name'))
+      .setDesc(t('settings.claudeSafeMode.desc'))
+      .addDropdown((dropdown) => {
+        for (const mode of CLAUDE_SAFE_MODES) {
+          dropdown.addOption(mode, mode);
+        }
+        dropdown
+          .setValue(claudeSettings.safeMode)
+          .onChange(async (value) => {
+            updateClaudeProviderSettings(
+              settingsBag,
+              { safeMode: value as ClaudeSafeMode },
+            );
+            await context.plugin.saveSettings();
+          });
+      });
+
+    new Setting(container)
+      .setName(t('settings.loadUserSettings.name'))
+      .setDesc(t('settings.loadUserSettings.desc'))
+      .addToggle((toggle) =>
+        toggle
+          .setValue(claudeSettings.loadUserSettings)
+          .onChange(async (value) => {
+            updateClaudeProviderSettings(settingsBag, { loadUserSettings: value });
+            await context.plugin.saveSettings();
+          })
+      );
+
+    // --- Models ---
+
+    new Setting(container).setName(t('settings.models')).setHeading();
+
+    new Setting(container)
+      .setName(t('settings.enableOpus1M.name'))
+      .setDesc(t('settings.enableOpus1M.desc'))
+      .addToggle((toggle) =>
+        toggle
+          .setValue(claudeSettings.enableOpus1M)
+          .onChange(async (value) => {
+            updateClaudeProviderSettings(settingsBag, { enableOpus1M: value });
+            context.plugin.normalizeModelVariantSettings();
+            await context.plugin.saveSettings();
+            context.refreshModelSelectors();
+          })
+      );
+
+    new Setting(container)
+      .setName(t('settings.enableSonnet1M.name'))
+      .setDesc(t('settings.enableSonnet1M.desc'))
+      .addToggle((toggle) =>
+        toggle
+          .setValue(claudeSettings.enableSonnet1M)
+          .onChange(async (value) => {
+            updateClaudeProviderSettings(settingsBag, { enableSonnet1M: value });
+            context.plugin.normalizeModelVariantSettings();
+            await context.plugin.saveSettings();
+            context.refreshModelSelectors();
+          })
+      );
+
+    new Setting(container)
+      .setName(t('settings.customModels.name'))
+      .setDesc(t('settings.customModels.desc'))
+      .addTextArea((text) => {
+        let pendingCustomModels = claudeSettings.customModels;
+        let savedCustomModels = claudeSettings.customModels;
+
+        const commitCustomModels = async (): Promise<void> => {
+          const previousCustomModels = savedCustomModels;
+          const previousModel = typeof settingsBag.model === 'string' ? settingsBag.model : '';
+          const previousTitleModel = typeof settingsBag.titleGenerationModel === 'string'
+            ? settingsBag.titleGenerationModel
+            : '';
+
+          if (pendingCustomModels !== savedCustomModels) {
+            updateClaudeProviderSettings(settingsBag, { customModels: pendingCustomModels });
+            savedCustomModels = pendingCustomModels;
+          }
+
+          reconcileActiveClaudeModelSelection();
+          const didReconcileTitleModel = ProviderSettingsCoordinator
+            .reconcileTitleGenerationModelSelection(settingsBag);
+          const nextModel = typeof settingsBag.model === 'string' ? settingsBag.model : '';
+          const nextTitleModel = typeof settingsBag.titleGenerationModel === 'string'
+            ? settingsBag.titleGenerationModel
+            : '';
+          const didModelSelectionChange = previousModel !== nextModel;
+          const didCustomModelsChange = previousCustomModels !== savedCustomModels;
+
+          if (!didCustomModelsChange && !didModelSelectionChange && !didReconcileTitleModel
+            && previousTitleModel === nextTitleModel) {
+            return;
+          }
+
+          await context.plugin.saveSettings();
+          context.refreshModelSelectors();
+        };
+
+        text
+          .setPlaceholder(t('settings.customModels.placeholder'))
+          .setValue(claudeSettings.customModels)
+          .onChange((value) => {
+            pendingCustomModels = value;
+          });
+        text.inputEl.rows = 6;
+        text.inputEl.cols = 40;
+        text.inputEl.addEventListener('blur', () => {
+          void commitCustomModels();
+        });
+      });
+
+    // --- Slash Commands ---
+
+    new Setting(container).setName(t('settings.slashCommands.name')).setHeading();
+
+    const slashCommandsDesc = container.createDiv({ cls: 'claudian-sp-settings-desc' });
+    const descP = slashCommandsDesc.createEl('p', { cls: 'setting-item-description' });
+    descP.appendText(t('settings.slashCommands.desc') + ' ');
+    descP.createEl('a', {
+      text: 'Learn more',
+      href: 'https://code.claude.com/docs/en/skills',
+    });
+
+    const slashCommandsContainer = container.createDiv({ cls: 'claudian-slash-commands-container' });
+    new SlashCommandSettings(
+      slashCommandsContainer,
+      context.plugin.app,
+      claudeWorkspace.commandCatalog,
+    );
+
+    context.renderHiddenProviderCommandSetting(container, 'claude', {
+      name: t('settings.hiddenSlashCommands.name'),
+      desc: t('settings.hiddenSlashCommands.desc'),
+      placeholder: t('settings.hiddenSlashCommands.placeholder'),
+    });
+
+    // --- Subagents ---
+
+    new Setting(container).setName(t('settings.subagents.name')).setHeading();
+
+    const agentsDesc = container.createDiv({ cls: 'claudian-sp-settings-desc' });
+    agentsDesc.createEl('p', {
+      text: t('settings.subagents.desc'),
+      cls: 'setting-item-description',
+    });
+
+    const agentsContainer = container.createDiv({ cls: 'claudian-agents-container' });
+    new AgentSettings(agentsContainer, {
+      app: context.plugin.app,
+      agentManager: claudeWorkspace.agentManager,
+      agentStorage: claudeWorkspace.agentStorage,
+    });
+
+    // --- MCP Servers ---
+
+    new Setting(container).setName(t('settings.mcpServers.name')).setHeading();
+
+    const mcpDesc = container.createDiv({ cls: 'claudian-mcp-settings-desc' });
+    mcpDesc.createEl('p', {
+      text: t('settings.mcpServers.desc'),
+      cls: 'setting-item-description',
+    });
+
+    const mcpContainer = container.createDiv({ cls: 'claudian-mcp-container' });
+    new McpSettingsManager(mcpContainer, {
+      app: context.plugin.app,
+      mcpStorage: claudeWorkspace.mcpStorage,
+      broadcastMcpReload: async () => {
+        for (const view of context.plugin.getAllViews()) {
+          await view.getTabManager()?.broadcastToAllTabs(
+            (service) => service.reloadMcpServers(),
+          );
+        }
+      },
+    });
+
+    // --- Plugins ---
+
+    new Setting(container).setName(t('settings.plugins.name')).setHeading();
+
+    const pluginsDesc = container.createDiv({ cls: 'claudian-plugin-settings-desc' });
+    pluginsDesc.createEl('p', {
+      text: t('settings.plugins.desc'),
+      cls: 'setting-item-description',
+    });
+
+    const pluginsContainer = container.createDiv({ cls: 'claudian-plugins-container' });
+    new PluginSettingsManager(pluginsContainer, {
+      pluginManager: claudeWorkspace.pluginManager,
+      agentManager: claudeWorkspace.agentManager,
+      restartTabs: async () => {
+        const view = context.plugin.getView();
+        const tabManager = view?.getTabManager();
+        if (!tabManager) {
+          return;
+        }
+
+        await tabManager.broadcastToAllTabs(
+          async (service) => { await service.ensureReady({ force: true }); },
+        );
+      },
+    });
+
+    // --- Environment ---
+
+    renderEnvironmentSettingsSection({
+      container,
+      plugin: context.plugin,
+      scope: 'provider:claude',
+      heading: t('settings.environment'),
+      name: t('settings.customVariables.name'),
+      desc: 'Claude-owned runtime variables only. Use this for ANTHROPIC_* and Claude-specific toggles.',
+      placeholder: 'ANTHROPIC_API_KEY=your-key\nANTHROPIC_BASE_URL=https://api.example.com\nANTHROPIC_MODEL=custom-model\nCLAUDE_CODE_USE_BEDROCK=1',
+      renderCustomContextLimits: (target) => context.renderCustomContextLimits(target, 'claude'),
+    });
+
+    // --- Experimental ---
+
+    new Setting(container).setName(t('settings.experimental')).setHeading();
+
+    new Setting(container)
+      .setName(t('settings.enableChrome.name'))
+      .setDesc(t('settings.enableChrome.desc'))
+      .addToggle((toggle) =>
+        toggle
+          .setValue(claudeSettings.enableChrome)
+          .onChange(async (value) => {
+            updateClaudeProviderSettings(settingsBag, { enableChrome: value });
+            await context.plugin.saveSettings();
+          })
+      );
+
+    new Setting(container)
+      .setName(t('settings.enableBangBash.name'))
+      .setDesc(t('settings.enableBangBash.desc'))
+      .addToggle((toggle) =>
+        toggle
+          .setValue(claudeSettings.enableBangBash)
+          .onChange(async (value) => {
+            bangBashValidationEl.toggleClass('claudian-hidden', true);
+            if (value) {
+              const { findNodeExecutable, getEnhancedPath } = await import('../../../utils/env');
+              const nodePath = findNodeExecutable(getEnhancedPath());
+              if (!nodePath) {
+                bangBashValidationEl.setText(t('settings.enableBangBash.validation.noNode'));
+                bangBashValidationEl.toggleClass('claudian-hidden', false);
+                toggle.setValue(false);
+                return;
+              }
+            }
+            updateClaudeProviderSettings(settingsBag, { enableBangBash: value });
+            await context.plugin.saveSettings();
+          })
+      );
+
+    const bangBashValidationEl = container.createDiv({
+      cls: 'claudian-bang-bash-validation claudian-setting-validation claudian-setting-validation-error claudian-hidden',
+    });
+  },
+};

package/src/providers/claude/ui/PluginSettingsManager.ts

@@ -0,0 +1,149 @@
+import { Notice, setIcon } from 'obsidian';
+
+import type {
+  AppAgentManager,
+  AppPluginManager,
+} from '../../../core/providers/types';
+import type { PluginInfo } from '../../../core/types';
+
+export interface PluginSettingsManagerDeps {
+  pluginManager: AppPluginManager;
+  agentManager: Pick<AppAgentManager, 'loadAgents'>;
+  restartTabs: () => Promise<void>;
+}
+
+export class PluginSettingsManager {
+  private containerEl: HTMLElement;
+  private pluginManager: AppPluginManager;
+  private agentManager: Pick<AppAgentManager, 'loadAgents'>;
+  private restartTabs: () => Promise<void>;
+
+  constructor(containerEl: HTMLElement, deps: PluginSettingsManagerDeps) {
+    this.containerEl = containerEl;
+    this.pluginManager = deps.pluginManager;
+    this.agentManager = deps.agentManager;
+    this.restartTabs = deps.restartTabs;
+    this.render();
+  }
+
+  private render() {
+    this.containerEl.empty();
+
+    const headerEl = this.containerEl.createDiv({ cls: 'claudian-plugin-header' });
+    headerEl.createSpan({ text: 'Claude Code Plugins', cls: 'claudian-plugin-label' });
+
+    const refreshBtn = headerEl.createEl('button', {
+      cls: 'claudian-settings-action-btn',
+      attr: { 'aria-label': 'Refresh' },
+    });
+    setIcon(refreshBtn, 'refresh-cw');
+    refreshBtn.addEventListener('click', () => {
+      void this.refreshPlugins();
+    });
+
+    const plugins = this.pluginManager.getPlugins();
+
+    if (plugins.length === 0) {
+      const emptyEl = this.containerEl.createDiv({ cls: 'claudian-plugin-empty' });
+      emptyEl.setText('No Claude code plugins found. Enable plugins via the Claude CLI.');
+      return;
+    }
+
+    const projectPlugins = plugins.filter(p => p.scope === 'project');
+    const userPlugins = plugins.filter(p => p.scope === 'user');
+
+    const listEl = this.containerEl.createDiv({ cls: 'claudian-plugin-list' });
+
+    if (projectPlugins.length > 0) {
+      const sectionHeader = listEl.createDiv({ cls: 'claudian-plugin-section-header' });
+      sectionHeader.setText('Project plugins');
+
+      for (const plugin of projectPlugins) {
+        this.renderPluginItem(listEl, plugin);
+      }
+    }
+
+    if (userPlugins.length > 0) {
+      const sectionHeader = listEl.createDiv({ cls: 'claudian-plugin-section-header' });
+      sectionHeader.setText('User plugins');
+
+      for (const plugin of userPlugins) {
+        this.renderPluginItem(listEl, plugin);
+      }
+    }
+  }
+
+  private renderPluginItem(listEl: HTMLElement, plugin: PluginInfo) {
+    const itemEl = listEl.createDiv({ cls: 'claudian-plugin-item' });
+    if (!plugin.enabled) {
+      itemEl.addClass('claudian-plugin-item-disabled');
+    }
+
+    const statusEl = itemEl.createDiv({ cls: 'claudian-plugin-status' });
+    if (plugin.enabled) {
+      statusEl.addClass('claudian-plugin-status-enabled');
+    } else {
+      statusEl.addClass('claudian-plugin-status-disabled');
+    }
+
+    const infoEl = itemEl.createDiv({ cls: 'claudian-plugin-info' });
+
+    const nameRow = infoEl.createDiv({ cls: 'claudian-plugin-name-row' });
+
+    const nameEl = nameRow.createSpan({ cls: 'claudian-plugin-name' });
+    nameEl.setText(plugin.name);
+
+    const actionsEl = itemEl.createDiv({ cls: 'claudian-plugin-actions' });
+
+    const toggleBtn = actionsEl.createEl('button', {
+      cls: 'claudian-plugin-action-btn',
+      attr: { 'aria-label': plugin.enabled ? 'Disable' : 'Enable' },
+    });
+    setIcon(toggleBtn, plugin.enabled ? 'toggle-right' : 'toggle-left');
+    toggleBtn.addEventListener('click', () => {
+      void this.togglePlugin(plugin.id);
+    });
+  }
+
+  private async togglePlugin(pluginId: string) {
+    const plugin = this.pluginManager.getPlugins().find(p => p.id === pluginId);
+    const wasEnabled = plugin?.enabled ?? false;
+
+    try {
+      await this.pluginManager.togglePlugin(pluginId);
+      await this.agentManager.loadAgents();
+
+      try {
+        await this.restartTabs();
+      } catch {
+        new Notice('Plugin toggled, but some tabs failed to restart.');
+      }
+
+      new Notice(`Plugin "${pluginId}" ${wasEnabled ? 'disabled' : 'enabled'}`);
+    } catch (err) {
+      await this.pluginManager.togglePlugin(pluginId);
+      const message = err instanceof Error ? err.message : 'Unknown error';
+      new Notice(`Failed to toggle plugin: ${message}`);
+    } finally {
+      this.render();
+    }
+  }
+
+  private async refreshPlugins() {
+    try {
+      await this.pluginManager.loadPlugins();
+      await this.agentManager.loadAgents();
+
+      new Notice('Plugin list refreshed');
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Unknown error';
+      new Notice(`Failed to refresh plugins: ${message}`);
+    } finally {
+      this.render();
+    }
+  }
+
+  public refresh() {
+    this.render();
+  }
+}