@yancyyu/openhermit 1.5.8

package/src/shared/utils/extensionNormalizers.ts

@@ -0,0 +1,336 @@
+/**
+ * Pure-function normalizers for Extension Store data.
+ */
+
+import {
+  getCliProviderExtensionCapability,
+  isCliExtensionCapabilityMutable,
+} from './providerExtensionCapabilities';
+
+import type {
+  CliInstallationStatus,
+  InstalledMcpEntry,
+  InstalledPluginEntry,
+  InstallScope,
+  PluginCapability,
+  PluginCatalogItem,
+} from '@shared/types';
+
+/**
+ * Normalize a repository URL for dedup comparison.
+ * Lowercases, strips `.git` suffix, strips trailing `/`.
+ */
+export function normalizeRepoUrl(url: string): string {
+  return url
+    .toLowerCase()
+    .replace(/\.git$/, '')
+    .replace(
+      /* eslint-disable-next-line sonarjs/slow-regex -- trailing slashes only, URL length bounded */
+      /\/+$/,
+      ''
+    );
+}
+
+/**
+ * Derive UI-visible capability labels from plugin capability flags.
+ */
+export function inferCapabilities(item: PluginCatalogItem): PluginCapability[] {
+  const caps: PluginCapability[] = [];
+  if (item.hasLspServers) caps.push('lsp');
+  if (item.hasMcpServers) caps.push('mcp');
+  if (item.hasAgents) caps.push('agent');
+  if (item.hasCommands) caps.push('command');
+  if (item.hasHooks) caps.push('hook');
+  if (caps.length === 0) caps.push('skill');
+  return caps;
+}
+
+const CAPABILITY_LABELS: Record<PluginCapability, string> = {
+  lsp: 'LSP',
+  mcp: 'MCP',
+  agent: 'Agent',
+  command: 'Command',
+  hook: 'Hook',
+  skill: 'Skill',
+};
+
+/**
+ * Get a human-readable label for the primary capability.
+ */
+export function getPrimaryCapabilityLabel(capabilities: PluginCapability[]): string {
+  if (capabilities.length === 0) return 'Skill';
+  return CAPABILITY_LABELS[capabilities[0]];
+}
+
+/**
+ * Get human-readable label for a capability.
+ */
+export function getCapabilityLabel(capability: PluginCapability): string {
+  return CAPABILITY_LABELS[capability];
+}
+
+/**
+ * Format large install counts for display.
+ * 277472 → "277K", 1200000 → "1.2M", 42 → "42"
+ */
+export function formatInstallCount(count: number): string {
+  if (count >= 1_000_000) {
+    const millions = count / 1_000_000;
+    return millions >= 10
+      ? `${Math.round(millions)}M`
+      : `${millions.toFixed(1).replace(/\.0$/, '')}M`;
+  }
+  if (count >= 1_000) {
+    const thousands = count / 1_000;
+    return thousands >= 10
+      ? `${Math.round(thousands)}K`
+      : `${thousands.toFixed(1).replace(/\.0$/, '')}K`;
+  }
+  return String(count);
+}
+
+/**
+ * Normalize a category string for consistent comparison/display.
+ * Lowercases, trims, falls back to "other".
+ */
+export function normalizeCategory(raw: string | undefined): string {
+  if (!raw) return 'other';
+  const normalized = raw.trim().toLowerCase();
+  return normalized || 'other';
+}
+
+/**
+ * Build a pluginId (= qualifiedName) from marketplace plugin name + marketplace name.
+ */
+export function buildPluginId(pluginName: string, marketplaceName: string): string {
+  return `${pluginName}@${marketplaceName}`;
+}
+
+/**
+ * Namespaced operation-state key for plugin install/uninstall UI state.
+ */
+export function getPluginOperationKey(
+  pluginId: string,
+  scope: InstallScope,
+  projectPath?: string | null
+): string {
+  if (scope === 'project' || scope === 'local') {
+    return `plugin:${pluginId}:${scope}:${getMcpProjectStateKey(projectPath)}`;
+  }
+  return `plugin:${pluginId}:${scope}`;
+}
+
+/**
+ * Namespaced operation-state key for MCP install/uninstall UI state.
+ */
+export function getMcpOperationKey(
+  registryId: string,
+  scope: InstallScope,
+  projectPath?: string | null
+): string {
+  if (scope === 'project' || scope === 'local') {
+    return `mcp:${registryId}:${scope}:${getMcpProjectStateKey(projectPath)}`;
+  }
+  return `mcp:${registryId}:${scope}`;
+}
+
+/**
+ * Namespaced lookup key for MCP diagnostics. Scope is included when available
+ * so the same server name can coexist across global/project/local installs.
+ */
+export function getMcpDiagnosticKey(name: string, scope?: string | null): string {
+  return scope ? `mcp-diagnostic:${scope}:${name}` : `mcp-diagnostic:${name}`;
+}
+
+/**
+ * Stable project-aware cache key for MCP installed/diagnostics state.
+ */
+export function getMcpProjectStateKey(projectPath?: string | null): string {
+  return projectPath ?? '__global__';
+}
+
+/**
+ * Check whether a plugin has an installation for the selected scope.
+ */
+export function hasInstallationInScope(
+  installations: Pick<InstalledPluginEntry, 'scope'>[],
+  scope: InstallScope
+): boolean {
+  return installations.some((installation) => installation.scope === scope);
+}
+
+function summarizeInstallationScopes(scopes: InstallScope[]): string | null {
+  if (scopes.length === 0) {
+    return null;
+  }
+
+  if (scopes.length > 1) {
+    return `已安装到 ${scopes.length} 个范围`;
+  }
+
+  switch (scopes[0]) {
+    case 'global':
+    case 'user':
+      return '已全局安装';
+    case 'project':
+      return '已安装到项目';
+    case 'local':
+      return '已安装到本地';
+    default:
+      return '已安装';
+  }
+}
+
+/**
+ * Build a concise install-status label for plugin badges.
+ */
+export function getInstallationSummaryLabel(
+  installations: Pick<InstalledPluginEntry, 'scope'>[]
+): string | null {
+  const scopes = Array.from(new Set(installations.map((installation) => installation.scope)));
+  return summarizeInstallationScopes(scopes);
+}
+
+const MCP_SCOPE_PRIORITY: Record<InstalledMcpEntry['scope'], number> = {
+  local: 0,
+  project: 1,
+  global: 2,
+  user: 2,
+};
+
+/**
+ * Pick the MCP installation entry that Claude will actually use.
+ * Scope precedence matches Claude Code: local > project > user.
+ */
+export function getPreferredMcpInstallationEntry(
+  installations: InstalledMcpEntry[]
+): InstalledMcpEntry | null {
+  if (installations.length === 0) {
+    return null;
+  }
+
+  return [...installations].sort(
+    (left, right) => MCP_SCOPE_PRIORITY[left.scope] - MCP_SCOPE_PRIORITY[right.scope]
+  )[0];
+}
+
+/**
+ * Build a concise install-status label for MCP badges.
+ */
+export function getMcpInstallationSummaryLabel(
+  installations: Pick<InstalledMcpEntry, 'scope'>[]
+): string | null {
+  const scopes = Array.from(new Set(installations.map((installation) => installation.scope)));
+  return summarizeInstallationScopes(scopes);
+}
+
+/**
+ * Install actions require Claude auth, but uninstall only requires a working CLI.
+ */
+export function getExtensionActionDisableReason(options: {
+  isInstalled: boolean;
+  cliStatus: Pick<
+    CliInstallationStatus,
+    'installed' | 'authLoggedIn' | 'binaryPath' | 'launchError' | 'flavor' | 'providers'
+  > | null;
+  cliStatusLoading: boolean;
+  section?: 'plugins' | 'mcp';
+}): string | null {
+  const { isInstalled, cliStatus, cliStatusLoading, section = 'plugins' } = options;
+  if (cliStatus === null) {
+    return cliStatusLoading ? '正在检查运行时状态...' : '正在检查运行时可用性...';
+  }
+
+  if (cliStatus.installed === false) {
+    if (cliStatus.binaryPath && cliStatus.launchError) {
+      return '已找到配置的运行时，但启动失败。请打开首页修复或重新安装。';
+    }
+    return '需要配置的运行时。请从首页安装或修复。';
+  }
+
+  const providers = cliStatus.providers ?? [];
+  const isMultimodel = cliStatus.flavor === 'agent_teams_orchestrator';
+
+  if (section === 'mcp') {
+    if (!isMultimodel) {
+      return null;
+    }
+
+    const mutableProviders = providers.filter((provider) =>
+      isCliExtensionCapabilityMutable(getCliProviderExtensionCapability(provider, 'mcp'))
+    );
+    if (mutableProviders.length > 0) {
+      return null;
+    }
+
+    const reason = providers
+      .map((provider) => getCliProviderExtensionCapability(provider, 'mcp').reason)
+      .find((value): value is string => typeof value === 'string' && value.trim().length > 0);
+
+    return reason ?? '当前运行时不支持 MCP 管理。';
+  }
+
+  if (!isMultimodel) {
+    if (!isInstalled && !cliStatus.authLoggedIn) {
+      return 'Claude CLI 已安装但尚未登录。请打开首页登录。';
+    }
+    return null;
+  }
+
+  const pluginProviders = providers.filter((provider) =>
+    isCliExtensionCapabilityMutable(getCliProviderExtensionCapability(provider, 'plugins'))
+  );
+
+  if (pluginProviders.length === 0) {
+    const reason = providers
+      .map((provider) => getCliProviderExtensionCapability(provider, 'plugins').reason)
+      .find((value): value is string => typeof value === 'string' && value.trim().length > 0);
+    return reason ?? '当前运行时不支持安装插件。';
+  }
+
+  if (isInstalled) {
+    return null;
+  }
+
+  const authenticatedProvider = pluginProviders.find((provider) => provider.authenticated);
+  if (!authenticatedProvider) {
+    return `${pluginProviders[0]?.displayName ?? 'Anthropic'} 未连接。请打开首页登录。`;
+  }
+
+  return null;
+}
+
+/**
+ * Sanitize an MCP server display name into a CLI-safe server name.
+ * Must match the regex /^[\w.-]{1,100}$/ required by McpInstallService.
+ */
+export function sanitizeMcpServerName(displayName: string): string {
+  return displayName
+    .toLowerCase()
+    .replace(/\s+/g, '-')
+    .replace(/[^\w.-]/g, '');
+}
+
+/**
+ * Extract owner/repo from a GitHub URL. Returns null for non-GitHub URLs.
+ * Handles: https://github.com/owner/repo, https://github.com/owner/repo.git, trailing slashes.
+ */
+export function parseGitHubOwnerRepo(url: string): { owner: string; repo: string } | null {
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname !== 'github.com') return null;
+    const parts = parsed.pathname
+      .replace(/^\//, '')
+      .replace(/\.git$/, '')
+      .replace(
+        /* eslint-disable-next-line sonarjs/slow-regex -- trailing slashes only, pathname bounded */
+        /\/+$/,
+        ''
+      )
+      .split('/');
+    if (parts.length < 2 || !parts[0] || !parts[1]) return null;
+    return { owner: parts[0], repo: parts[1] };
+  } catch {
+    return null;
+  }
+}

package/src/shared/utils/idleNotificationSemantics.ts

@@ -0,0 +1,86 @@
+import { isInboxNoiseMessage, parseInboxJson } from './inboxNoise';
+
+export interface IdleNotificationPayload {
+  type: 'idle_notification';
+  from?: string;
+  timestamp?: string;
+  idleReason?: 'available' | 'interrupted' | 'failed';
+  summary?: string;
+  completedTaskId?: string;
+  completedStatus?: 'resolved' | 'blocked' | 'failed';
+  failureReason?: string;
+}
+
+export type IdleNotificationPrimaryKind = 'heartbeat' | 'interrupted' | 'task_terminal' | 'failure';
+
+export interface ClassifiedIdleNotification {
+  payload: IdleNotificationPayload;
+  primaryKind: IdleNotificationPrimaryKind;
+  hasPeerSummary: boolean;
+  peerSummary: string | null;
+  countsAsBootstrapConfirmation: boolean;
+}
+
+function getTrimmedOptionalString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+
+function isIdleNotificationPayload(value: unknown): value is IdleNotificationPayload {
+  return (
+    !!value &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    (value as { type?: unknown }).type === 'idle_notification'
+  );
+}
+
+export function classifyIdleNotificationText(text: string): ClassifiedIdleNotification | null {
+  const parsed = parseInboxJson(text);
+  if (!isIdleNotificationPayload(parsed)) return null;
+
+  const peerSummary = getTrimmedOptionalString(parsed.summary);
+  const hasPeerSummary = peerSummary !== null;
+  const failureReason = getTrimmedOptionalString(parsed.failureReason);
+  const completedTaskId = getTrimmedOptionalString(parsed.completedTaskId);
+
+  let primaryKind: IdleNotificationPrimaryKind;
+  if (
+    parsed.idleReason === 'failed' ||
+    failureReason !== null ||
+    parsed.completedStatus === 'failed'
+  ) {
+    primaryKind = 'failure';
+  } else if (
+    completedTaskId !== null ||
+    parsed.completedStatus === 'resolved' ||
+    parsed.completedStatus === 'blocked'
+  ) {
+    primaryKind = 'task_terminal';
+  } else if (parsed.idleReason === 'interrupted') {
+    primaryKind = 'interrupted';
+  } else {
+    primaryKind = 'heartbeat';
+  }
+
+  return {
+    payload: parsed,
+    primaryKind,
+    hasPeerSummary,
+    peerSummary,
+    countsAsBootstrapConfirmation: primaryKind !== 'failure',
+  };
+}
+
+export function shouldSuppressDesktopNotificationForInboxText(text: string): boolean {
+  return classifyIdleNotificationText(text) !== null || isInboxNoiseMessage(text);
+}
+
+export function shouldExcludeInboxTextFromReplyCandidates(text: string): boolean {
+  return classifyIdleNotificationText(text) !== null || isInboxNoiseMessage(text);
+}
+
+export function getIdleGraphLabel(text: string): string | null {
+  const classified = classifyIdleNotificationText(text);
+  if (!classified) return null;
+  return classified.hasPeerSummary && classified.peerSummary ? classified.peerSummary : 'idle';
+}

package/src/shared/utils/inboxNoise.ts

@@ -0,0 +1,158 @@
+/**
+ * Inbox "noise" messages are structured JSON objects that represent internal coordination
+ * signals (idle/shutdown/etc.). They should not trigger user-facing notifications or
+ * automatic lead relays.
+ */
+export const INBOX_NOISE_TYPES = [
+  'idle_notification',
+  'shutdown_approved',
+  'teammate_terminated',
+  'shutdown_request',
+] as const;
+
+const INBOX_NOISE_SET = new Set<string>(INBOX_NOISE_TYPES);
+
+export function parseInboxJson(text: string): Record<string, unknown> | null {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('{')) return null;
+  try {
+    const parsed = JSON.parse(trimmed) as unknown;
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    // not JSON
+  }
+  return null;
+}
+
+export function getInboxJsonType(text: string): string | null {
+  const parsed = parseInboxJson(text);
+  if (!parsed) return null;
+  return typeof parsed.type === 'string' ? parsed.type : null;
+}
+
+export function isInboxNoiseMessage(text: string): boolean {
+  const type = getInboxJsonType(text);
+  return !!type && INBOX_NOISE_SET.has(type);
+}
+
+/**
+ * Returns true when a teammate message is substantive enough to count as a real
+ * bootstrap/check-in signal. Internal coordination noise like idle/shutdown
+ * JSON should keep the runtime marked alive, but must not be treated as a
+ * teammate "checked in" signal in launch UX.
+ */
+export function isMeaningfulBootstrapCheckInMessage(text: string): boolean {
+  return text.trim().length > 0 && !isInboxNoiseMessage(text);
+}
+
+// ---------------------------------------------------------------------------
+// Teammate permission request parsing
+// ---------------------------------------------------------------------------
+
+/** A single permission suggestion from the teammate runtime. */
+export interface PermissionSuggestion {
+  type: string;
+  rules?: { toolName: string }[];
+  behavior?: string;
+  destination?: string;
+  /** Permission mode name (for type: "setMode"). FACT: observed values: "acceptEdits", "bypassPermissions" */
+  mode?: string;
+}
+
+/** Parsed teammate permission request from inbox message. */
+export interface ParsedPermissionRequest {
+  requestId: string;
+  agentId: string;
+  toolName: string;
+  toolUseId: string;
+  description: string;
+  input: Record<string, unknown>;
+  /** Suggestions from teammate runtime on how to resolve the permission.
+   * FACT: This field is populated by Claude Code runtime, not by the AI agent.
+   * FACT: Observed format: { type: "addRules", rules: [{toolName}], behavior: "allow", destination: "localSettings" }
+   */
+  permissionSuggestions: PermissionSuggestion[];
+}
+
+/**
+ * Parses a `permission_request` JSON message from a teammate's inbox entry.
+ * Returns null if the text is not a valid permission_request.
+ */
+export function parsePermissionRequest(text: string): ParsedPermissionRequest | null {
+  const parsed = parseInboxJson(text);
+  if (parsed?.type !== 'permission_request') return null;
+
+  const requestId = typeof parsed.request_id === 'string' ? parsed.request_id : null;
+  const agentId = typeof parsed.agent_id === 'string' ? parsed.agent_id : null;
+  const toolName = typeof parsed.tool_name === 'string' ? parsed.tool_name : null;
+
+  if (!requestId || !agentId || !toolName) return null;
+
+  return {
+    requestId,
+    agentId,
+    toolName,
+    toolUseId: typeof parsed.tool_use_id === 'string' ? parsed.tool_use_id : '',
+    description: typeof parsed.description === 'string' ? parsed.description : '',
+    input:
+      parsed.input && typeof parsed.input === 'object' && !Array.isArray(parsed.input)
+        ? (parsed.input as Record<string, unknown>)
+        : {},
+    permissionSuggestions: Array.isArray(parsed.permission_suggestions)
+      ? (parsed.permission_suggestions as PermissionSuggestion[])
+      : [],
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Teammate-message XML block detection & stripping
+// ---------------------------------------------------------------------------
+
+const TEAMMATE_MESSAGE_BLOCK_RE = /<teammate-message\s[^>]*>[\s\S]*?<\/teammate-message>/g;
+
+/**
+ * Removes `<teammate-message>` XML blocks from text.
+ * Used to clean protocol artifacts that leak into lead thoughts.
+ */
+export function stripTeammateMessageBlocks(text: string): string {
+  return text
+    .replace(TEAMMATE_MESSAGE_BLOCK_RE, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/**
+ * Returns true if the entire text consists only of `<teammate-message>` blocks
+ * (possibly with whitespace between them) and no meaningful user-visible content.
+ */
+export function isOnlyTeammateMessageBlocks(text: string): boolean {
+  const stripped = stripTeammateMessageBlocks(text);
+  return stripped.length === 0;
+}
+
+// ---------------------------------------------------------------------------
+// Combined protocol noise check for lead thoughts
+// ---------------------------------------------------------------------------
+
+/**
+ * Detects `<teammate-message>` opening tags (even without closing tag).
+ * Claude's lead model sometimes echoes raw teammate message XML in assistant
+ * text output — these are always protocol artifacts, never real user content.
+ */
+const TEAMMATE_MESSAGE_OPEN_RE = /^\s*<teammate-message\s/;
+
+/**
+ * Returns true if a lead thought text is entirely protocol noise and should
+ * be hidden from the user.  Covers:
+ * 1. Structured JSON noise (idle_notification, shutdown_*, etc.)
+ * 2. Text that consists solely of `<teammate-message>` XML blocks (closed tags)
+ * 3. Text starting with an unclosed `<teammate-message>` tag
+ */
+export function isThoughtProtocolNoise(text: string): boolean {
+  if (isInboxNoiseMessage(text)) return true;
+  if (isOnlyTeammateMessageBlocks(text)) return true;
+  if (TEAMMATE_MESSAGE_OPEN_RE.test(text)) return true;
+  return false;
+}

package/src/shared/utils/leadDetection.ts

@@ -0,0 +1,63 @@
+/**
+ * Team lead identity rules.
+ *
+ * Internal storage uses one canonical member name: "team-lead".
+ * Runtime/legacy data may still contain "lead"; treat it as an alias only.
+ * UI should display this member as "负责人" instead of leaking either id.
+ */
+
+export const CANONICAL_LEAD_MEMBER_NAME = 'team-lead';
+export const LEGACY_LEAD_MEMBER_NAME = 'lead';
+export const LEAD_DISPLAY_NAME = '负责人';
+
+const LEAD_MEMBER_NAME_ALIASES = new Set([CANONICAL_LEAD_MEMBER_NAME, LEGACY_LEAD_MEMBER_NAME]);
+const LEAD_AGENT_TYPES = new Set([
+  CANONICAL_LEAD_MEMBER_NAME,
+  LEGACY_LEAD_MEMBER_NAME,
+  'orchestrator',
+]);
+const LEAD_MEMBER_ROLES = new Set(['lead']);
+
+function normalizeLeadIdentity(value: string | undefined | null): string {
+  return value?.trim().toLowerCase() ?? '';
+}
+
+export function isLeadMemberName(name: string | undefined | null): boolean {
+  return LEAD_MEMBER_NAME_ALIASES.has(normalizeLeadIdentity(name));
+}
+
+export function resolveLeadMemberName(name: string | undefined | null): string {
+  return isLeadMemberName(name) ? CANONICAL_LEAD_MEMBER_NAME : (name?.trim() ?? '');
+}
+
+/**
+ * Returns true if the given agentType string identifies a team lead.
+ * Handles the canonical app value plus runtime labels.
+ *
+ * Does NOT match "general-purpose" — that value is ambiguous and used
+ * for regular teammates too. Lead detection for "general-purpose" agents
+ * must rely on name-based checks (see {@link isLeadMember}).
+ */
+export function isLeadAgentType(agentType: string | undefined | null): boolean {
+  return LEAD_AGENT_TYPES.has(normalizeLeadIdentity(agentType));
+}
+
+/**
+ * Returns true if the role string identifies a team lead.
+ */
+export function isLeadMemberRole(role: string | undefined | null): boolean {
+  return LEAD_MEMBER_ROLES.has(normalizeLeadIdentity(role));
+}
+
+/**
+ * Returns true if the member is a team lead, checking both agentType
+ * and the canonical internal lead name as a fallback.
+ */
+export function isLeadMember(member: { agentType?: unknown; name?: unknown; role?: unknown }): boolean {
+  const role = typeof member.role === 'string' ? member.role : null;
+  if (isLeadMemberRole(role)) return true;
+  const agentType = typeof member.agentType === 'string' ? member.agentType : null;
+  if (isLeadAgentType(agentType)) return true;
+  const name = typeof member.name === 'string' ? member.name : null;
+  return isLeadMemberName(name);
+}