@yancyyu/openhermit 1.5.8

package/src/main/types/messages.ts

@@ -0,0 +1,395 @@
+/**
+ * Parsed message types and type guards for Hermit.
+ *
+ * ParsedMessage is the application's internal representation after parsing
+ * raw JSONL entries. This module also contains type guards for classifying
+ * parsed messages into categories for chunk building.
+ */
+
+import {
+  EMPTY_STDERR,
+  EMPTY_STDOUT,
+  HARD_NOISE_TAGS,
+  LOCAL_COMMAND_STDERR_TAG,
+  LOCAL_COMMAND_STDOUT_TAG,
+  SYSTEM_OUTPUT_TAGS,
+} from '../constants/messageTags';
+
+import { type MessageType, type TokenUsage } from './domain';
+import { type ContentBlock, type ToolUseResultData } from './jsonl';
+
+// =============================================================================
+// Tool Types
+// =============================================================================
+
+/**
+ * Tool call extracted from assistant message.
+ */
+export interface ToolCall {
+  /** Tool use ID for linking to results */
+  id: string;
+  /** Tool name */
+  name: string;
+  /** Tool input parameters */
+  input: Record<string, unknown>;
+  /** Whether this is a Task (subagent) tool call */
+  isTask: boolean;
+  /** Task description if isTask */
+  taskDescription?: string;
+  /** Task subagent type if isTask */
+  taskSubagentType?: string;
+}
+
+/**
+ * Tool result extracted from user message.
+ */
+export interface ToolResult {
+  /** Corresponding tool_use ID */
+  toolUseId: string;
+  /** Result content */
+  content: string | unknown[];
+  /** Whether the tool execution errored */
+  isError: boolean;
+}
+
+// =============================================================================
+// Parsed Message
+// =============================================================================
+
+/**
+ * Parsed and enriched message from JSONL.
+ * This is the application's internal representation after parsing raw JSONL entries.
+ */
+export interface ParsedMessage {
+  /** Unique message identifier */
+  uuid: string;
+  /** Parent message UUID for threading */
+  parentUuid: string | null;
+  /** Message type */
+  type: MessageType;
+  /** Message timestamp */
+  timestamp: Date;
+  /** Message role if present */
+  role?: string;
+  /** Message content (string or content blocks) */
+  content: ContentBlock[] | string;
+  /** Token usage for this message */
+  usage?: TokenUsage;
+  /** Model used for this response */
+  model?: string;
+  // Metadata
+  /** Current working directory when message was created */
+  cwd?: string;
+  /** Root/session identifier from transcript */
+  sessionId?: string;
+  /** Git branch context */
+  gitBranch?: string;
+  /** Agent ID for subagent messages */
+  agentId?: string;
+  /** Human-readable agent/member name from transcript */
+  agentName?: string;
+  /** Whether this is a sidechain message */
+  isSidechain: boolean;
+  /** Whether this is a meta message */
+  isMeta: boolean;
+  /** User type ("external" for user input) */
+  userType?: string;
+  // Extracted tool information
+  /** Tool calls made in this message */
+  toolCalls: ToolCall[];
+  /** Tool results received in this message */
+  toolResults: ToolResult[];
+  /** Source tool use ID if this is a tool result message */
+  sourceToolUseID?: string;
+  /** Source assistant UUID if this is a tool result message */
+  sourceToolAssistantUUID?: string;
+  /** Tool use result information if this is a tool result message */
+  toolUseResult?: ToolUseResultData;
+  /** Whether this is a compact summary boundary message */
+  isCompactSummary?: boolean;
+  /** API request ID for deduplicating streaming entries */
+  requestId?: string;
+  /** System-message severity when available in the raw transcript */
+  level?: string;
+  /** Raw system subtype when available in the transcript */
+  subtype?: string;
+  codexNativeWarningSource?: string;
+  codexNativeThreadStatus?: string;
+  codexNativeThreadId?: string;
+  codexNativeCompletionPolicy?: string;
+  codexNativeHistoryCompleteness?: string;
+  codexNativeFinalUsageAuthority?: string;
+  codexNativeExecutablePath?: string;
+  codexNativeExecutableSource?: string;
+  codexNativeExecutableVersion?: string | null;
+}
+
+// =============================================================================
+// ParsedMessage Type Guards
+// =============================================================================
+
+/**
+ * Type guard to check if a ParsedMessage is a real user message.
+ * This wraps the spec's type guard but works with ParsedMessage instead of UserEntry.
+ *
+ * Accepts both formats:
+ * - Older sessions: content as string
+ * - Newer sessions: content as array with text/image blocks
+ *
+ * Excludes command output messages (with <local-command-stdout>) which should
+ * be treated as system responses, not user input that starts new chunks.
+ */
+export function isParsedRealUserMessage(msg: ParsedMessage): boolean {
+  if (msg.type !== 'user') return false;
+  if (msg.isMeta) return false;
+
+  const content = msg.content;
+
+  // String content format (older sessions)
+  if (typeof content === 'string') {
+    return true;
+  }
+
+  // Array content format (newer sessions)
+  if (Array.isArray(content)) {
+    // Check if it contains text or image blocks (real user input)
+    // Exclude arrays with only tool_result blocks (those are internal messages)
+    return content.some((block) => block.type === 'text' || block.type === 'image');
+  }
+
+  return false;
+}
+
+/**
+ * Type guard for User chunk creation - genuine user input that starts User chunks.
+ *
+ * Returns true if message should create a User chunk:
+ * - type='user'
+ * - isMeta!=true
+ * - Has text/image content
+ * - Content does NOT contain: <local-command-stdout>, <local-command-caveat>, <system-reminder>
+ * - Content MAY contain: <command-name> (slash commands like /model ARE user input)
+ *
+ * Example User chunk messages:
+ * - "Help me debug this code"
+ * - "<command-name>/model</command-name> Switch to sonnet"
+ *
+ * NOT User chunks:
+ * - "<local-command-stdout>Set model to...</local-command-stdout>" -> System chunk
+ * - "<local-command-caveat>...</local-command-caveat>" -> Hard noise
+ * - "<system-reminder>...</system-reminder>" -> Hard noise
+ */
+export function isParsedUserChunkMessage(msg: ParsedMessage): boolean {
+  if (msg.type !== 'user') return false;
+  if (msg.isMeta === true) return false;
+  if (isParsedTeammateMessage(msg)) return false;
+
+  const content = msg.content;
+
+  // Check string content
+  if (typeof content === 'string') {
+    const trimmed = content.trim();
+
+    // Exclude messages that are system output or system metadata
+    // These tags indicate system-generated content, not user input
+    for (const tag of SYSTEM_OUTPUT_TAGS) {
+      if (trimmed.startsWith(tag)) {
+        return false;
+      }
+    }
+
+    // <command-name> is ALLOWED - it's user-initiated slash commands
+    // Remaining content is genuine user input
+    return trimmed.length > 0;
+  }
+
+  // Array content format (newer sessions)
+  if (Array.isArray(content)) {
+    // Must contain text or image blocks for real user input
+    const hasUserContent = content.some((block) => block.type === 'text' || block.type === 'image');
+
+    if (!hasUserContent) {
+      return false;
+    }
+
+    // Filter out user interruption messages (should be part of AI response flow)
+    // These have exactly 1 text block with content like "[Request interrupted by user]"
+    // or "[Request interrupted by user for tool use]"
+    if (
+      content.length === 1 &&
+      content[0].type === 'text' &&
+      typeof content[0].text === 'string' &&
+      content[0].text.startsWith('[Request interrupted by user')
+    ) {
+      return false;
+    }
+
+    // Check text blocks for excluded tags
+    for (const block of content) {
+      if (block.type === 'text') {
+        const textBlock = block;
+        for (const tag of SYSTEM_OUTPUT_TAGS) {
+          if (textBlock.text.startsWith(tag)) {
+            return false;
+          }
+        }
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Type guard for System chunk creation - command output messages.
+ *
+ * Returns true if message should create a System chunk:
+ * - type='user' (confusingly, command output comes as user entries in JSONL)
+ * - Contains <local-command-stdout> tag
+ *
+ * System chunks render on the LEFT side (like AI responses) with neutral gray styling.
+ *
+ * Example:
+ * ```
+ * {
+ *   type: "user",
+ *   content: "<local-command-stdout>Set model to sonnet...</local-command-stdout>"
+ * }
+ * ```
+ */
+export function isParsedSystemChunkMessage(msg: ParsedMessage): boolean {
+  if (msg.type !== 'user') return false;
+
+  const content = msg.content;
+
+  if (typeof content === 'string') {
+    return (
+      content.startsWith(LOCAL_COMMAND_STDOUT_TAG) || content.startsWith(LOCAL_COMMAND_STDERR_TAG)
+    );
+  }
+
+  // Array content - check text blocks
+  if (Array.isArray(content)) {
+    return content.some(
+      (block) => block.type === 'text' && block.text.startsWith(LOCAL_COMMAND_STDOUT_TAG)
+    );
+  }
+
+  return false;
+}
+
+/**
+ * Type guard to check if a ParsedMessage is an internal user message.
+ * This wraps the spec's type guard but works with ParsedMessage instead of UserEntry.
+ */
+export function isParsedInternalUserMessage(msg: ParsedMessage): boolean {
+  return msg.type === 'user' && msg.isMeta === true;
+}
+
+/**
+ * Hard noise message (ParsedMessage version) - NEVER rendered or counted in the UI.
+ * This wraps isHardNoiseMessage() but works with ParsedMessage instead of ChatHistoryEntry.
+ *
+ * Filtered messages:
+ * - Messages with parentUuid: null (orphaned/root messages that shouldn't display)
+ *   - e.g., compact_boundary system messages, root-level meta messages
+ *
+ * Filtered types:
+ * - 'system' entries
+ * - 'summary' entries
+ * - 'file-history-snapshot' entries
+ * - 'queue-operation' entries
+ *
+ * Filtered user messages:
+ * - Messages containing ONLY these system metadata tags (no real content):
+ *   - <local-command-caveat>
+ *   - <system-reminder>
+ * - Empty command output: <local-command-stdout></local-command-stdout>
+ * - Interruption messages: [Request interrupted by user...]
+ *
+ * Filtered assistant messages:
+ * - Synthetic messages with model='<synthetic>' (system-generated placeholders)
+ */
+export function isParsedHardNoiseMessage(msg: ParsedMessage): boolean {
+  // Filter structural metadata types - these should never be displayed
+  if (msg.type === 'system') return true;
+  if (msg.type === 'summary') return true;
+  if (msg.type === 'file-history-snapshot') return true;
+  if (msg.type === 'queue-operation') return true;
+
+  // Filter synthetic assistant messages (system-generated placeholders)
+  if (msg.type === 'assistant' && msg.model === '<synthetic>') {
+    return true;
+  }
+
+  // Filter user messages with ONLY system metadata tags (no real content)
+  if (msg.type === 'user') {
+    const content = msg.content;
+
+    if (typeof content === 'string') {
+      // Check if content contains ONLY noise tags (trim whitespace)
+      const trimmedContent = content.trim();
+
+      // If the content is wrapped in a noise tag, it's hard noise
+      for (const tag of HARD_NOISE_TAGS) {
+        const openTag = tag;
+        const closeTag = tag.replace('<', '</');
+        if (trimmedContent.startsWith(openTag) && trimmedContent.endsWith(closeTag)) {
+          return true;
+        }
+      }
+
+      // Filter empty command output (e.g., /clear with no output)
+      if (trimmedContent === EMPTY_STDOUT || trimmedContent === EMPTY_STDERR) {
+        return true;
+      }
+
+      // Filter interruption messages (rendered via session state detection instead)
+      if (trimmedContent.startsWith('[Request interrupted by user')) {
+        return true;
+      }
+    }
+
+    // Filter array content with single interruption text block
+    if (Array.isArray(content)) {
+      if (
+        content.length === 1 &&
+        content[0].type === 'text' &&
+        typeof content[0].text === 'string' &&
+        content[0].text.startsWith('[Request interrupted by user')
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Detect compact summary messages.
+ * These are markers indicating conversation was compacted.
+ */
+export function isParsedCompactMessage(msg: ParsedMessage): boolean {
+  return msg.isCompactSummary === true;
+}
+
+/**
+ * Detect teammate messages - messages from team member agents.
+ * Format: <teammate-message teammate_id="name" ...>content</teammate-message>
+ */
+const TEAMMATE_MESSAGE_REGEX = /^<teammate-message\s+teammate_id="([^"]+)"/;
+
+function isParsedTeammateMessage(msg: ParsedMessage): boolean {
+  if (msg.type !== 'user' || msg.isMeta) return false;
+  const content = msg.content;
+  if (typeof content === 'string') return TEAMMATE_MESSAGE_REGEX.test(content.trim());
+  if (Array.isArray(content)) {
+    return content.some(
+      (block) => block.type === 'text' && TEAMMATE_MESSAGE_REGEX.test(block.text.trim())
+    );
+  }
+  return false;
+}

package/src/renderer/App.tsx

@@ -0,0 +1,287 @@
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+
+import { TooltipProvider } from '@renderer/components/ui/tooltip';
+
+import { ConfirmDialog } from './components/common/ConfirmDialog';
+import { ContextSwitchOverlay } from './components/common/ContextSwitchOverlay';
+import { ErrorBoundary } from './components/common/ErrorBoundary';
+import { TabbedLayout } from './components/layout/TabbedLayout';
+import { type SplashSceneHandle, startSplashScene } from './components/splash/splashScene';
+import { ToolApprovalSheet } from './components/team/ToolApprovalSheet';
+import { useTheme } from './hooks/useTheme';
+import { api } from './api';
+import { useStore } from './store';
+
+import type { PaneLayout } from './types/panes';
+import type { Tab } from './types/tabs';
+
+const PERSIST_KEY = 'hermit:lastTeam';
+const DEFAULT_APP_PATH = '/teams';
+
+function safeDecodeURIComponent(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function getActiveTabFromLayout(activeTabId: string | null, paneLayout: PaneLayout): Tab | null {
+  if (!activeTabId) return null;
+  for (const pane of paneLayout.panes) {
+    const tab = pane.tabs.find((item) => item.id === activeTabId);
+    if (tab) return tab;
+  }
+  return null;
+}
+
+function buildPathForTab(activeTab: Tab | null): string {
+  if (!activeTab) {
+    return DEFAULT_APP_PATH;
+  }
+  switch (activeTab.type) {
+    case 'team':
+      return activeTab.teamName ? `/team/${encodeURIComponent(activeTab.teamName)}` : DEFAULT_APP_PATH;
+    case 'teams':
+      return '/teams';
+    case 'settings':
+      return '/settings';
+    case 'extensions':
+      return '/extensions';
+    case 'schedules':
+      return '/schedules';
+    case 'dashboard':
+      return '/dashboard';
+    case 'session': {
+      if (!activeTab.projectId || !activeTab.sessionId) return DEFAULT_APP_PATH;
+      return `/session/${encodeURIComponent(activeTab.projectId)}/${encodeURIComponent(activeTab.sessionId)}`;
+    }
+    case 'notifications':
+      return '/notifications';
+    case 'graph':
+      return activeTab.teamName
+        ? `/graph/${encodeURIComponent(activeTab.teamName)}`
+        : '/graph';
+    case 'report':
+      return activeTab.projectId && activeTab.sessionId
+        ? `/report/${encodeURIComponent(activeTab.projectId)}/${encodeURIComponent(activeTab.sessionId)}`
+        : '/report';
+    default:
+      return DEFAULT_APP_PATH;
+  }
+}
+
+function useTeamPersistence() {
+  // Restore last team on mount
+  useEffect(() => {
+    if (window.location.pathname !== '/' && window.location.pathname !== '') {
+      return;
+    }
+    try {
+      const teamName = localStorage.getItem(PERSIST_KEY);
+      if (teamName) {
+        setTimeout(() => {
+          const s = useStore.getState();
+          if (!s.selectedTeamName) {
+            s.selectTeam(teamName);
+          }
+        }, 500);
+      }
+    } catch { /* ignore */ }
+  }, []);
+
+  // Save team when it changes
+  useEffect(() => {
+    const unsub = useStore.subscribe((state, prevState) => {
+      if (state.selectedTeamName !== prevState.selectedTeamName && state.selectedTeamName) {
+        try { localStorage.setItem(PERSIST_KEY, state.selectedTeamName); } catch { /* ignore */ }
+      }
+    });
+    return unsub;
+  }, []);
+}
+
+function useTabPathPersistence() {
+  const { activeTabId, paneLayout } = useStore((s) => ({
+    activeTabId: s.activeTabId,
+    paneLayout: s.paneLayout,
+  }));
+  const [routeReady, setRouteReady] = useState(false);
+  const didInitialRouteRestoreRef = useRef(false);
+
+  useEffect(() => {
+    if (didInitialRouteRestoreRef.current) return;
+    didInitialRouteRestoreRef.current = true;
+
+    const pathname = window.location.pathname;
+    const segments = pathname
+      .split('/')
+      .map((segment) => segment.trim())
+      .filter((segment) => segment.length > 0)
+      .map(safeDecodeURIComponent);
+    const state = useStore.getState();
+
+    if (segments.length === 0) {
+      setRouteReady(true);
+      return;
+    }
+
+    const [route, arg1, arg2] = segments;
+    switch (route) {
+      case 'team':
+        if (arg1) state.openTeamTab(arg1);
+        break;
+      case 'teams':
+        state.openTeamsTab();
+        break;
+      case 'settings':
+        state.openSettingsTab();
+        break;
+      case 'extensions':
+        state.openExtensionsTab();
+        break;
+      case 'schedules':
+        state.openSchedulesTab();
+        break;
+      case 'dashboard':
+        state.openDashboard();
+        break;
+      case 'session':
+        if (arg1 && arg2) {
+          state.navigateToSession(arg1, arg2);
+        }
+        break;
+      case 'notifications':
+        state.openTab({ type: 'notifications', label: '通知' });
+        break;
+      case 'graph':
+        if (arg1) {
+          state.openTab({ type: 'graph', label: arg1, teamName: arg1 });
+        }
+        break;
+      case 'report':
+        if (arg1 && arg2) {
+          state.openTab({ type: 'report', label: 'Session Report', projectId: arg1, sessionId: arg2 });
+        }
+        break;
+      default:
+        break;
+    }
+
+    setRouteReady(true);
+  }, []);
+
+  const activeTab = useMemo(
+    () => getActiveTabFromLayout(activeTabId, paneLayout),
+    [activeTabId, paneLayout]
+  );
+
+  useEffect(() => {
+    if (!routeReady) return;
+    const nextPath = buildPathForTab(activeTab);
+    if (window.location.pathname === nextPath) return;
+    window.history.replaceState(null, '', nextPath);
+  }, [activeTab, routeReady]);
+}
+
+declare global {
+  interface Window {
+    __claudeTeamsSplashEnhancedStartedAt?: number;
+    __claudeTeamsSplashScene?: SplashSceneHandle;
+    __claudeTeamsSplashStartedAt?: number;
+  }
+}
+
+const SPLASH_MIN_DURATION_MS = 1600;
+const SPLASH_ENHANCED_HOLD_MS = 600;
+const SPLASH_FADE_MS = 480;
+const SPLASH_REDUCED_MIN_DURATION_MS = 320;
+const SPLASH_REDUCED_HOLD_MS = 120;
+const SPLASH_REDUCED_FADE_MS = 180;
+const SPLASH_AVATAR_READY_MAX_WAIT_MS = 900;
+const SPLASH_REDUCED_AVATAR_READY_MAX_WAIT_MS = 160;
+
+export const App = (): React.JSX.Element => {
+  // Initialize theme on app load
+  useTheme();
+
+  // Restore last team on page refresh
+  useTeamPersistence();
+  // Keep URL path in sync with active tab and restore from URL.
+  useTabPathPersistence();
+
+  // Upgrade the static preload splash, then dismiss it after the scene is visible.
+  useEffect(() => {
+    const splash = document.getElementById('splash');
+    if (splash) {
+      const reducedMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
+      const scene = window.__claudeTeamsSplashScene ?? startSplashScene(splash, { reducedMotion });
+      const startedAt = window.__claudeTeamsSplashStartedAt ?? performance.now();
+      const enhancedStartedAt = window.__claudeTeamsSplashEnhancedStartedAt ?? performance.now();
+      const elapsed = performance.now() - startedAt;
+      const enhancedElapsed = performance.now() - enhancedStartedAt;
+      const minDuration = reducedMotion ? SPLASH_REDUCED_MIN_DURATION_MS : SPLASH_MIN_DURATION_MS;
+      const enhancedHold = reducedMotion ? SPLASH_REDUCED_HOLD_MS : SPLASH_ENHANCED_HOLD_MS;
+      const fadeDuration = reducedMotion ? SPLASH_REDUCED_FADE_MS : SPLASH_FADE_MS;
+      const avatarReadyMaxWait = reducedMotion
+        ? SPLASH_REDUCED_AVATAR_READY_MAX_WAIT_MS
+        : SPLASH_AVATAR_READY_MAX_WAIT_MS;
+      const exitDelay = Math.max(minDuration - elapsed, enhancedHold - enhancedElapsed, 0);
+      let removeTimer: number | undefined;
+      let avatarReadyTimer: number | undefined;
+      let dismissed = false;
+
+      const dismissSplash = (): void => {
+        if (dismissed) return;
+        dismissed = true;
+        splash.classList.add('splash-exiting');
+        removeTimer = window.setTimeout(() => {
+          scene.stop();
+          window.__claudeTeamsSplashScene = undefined;
+          window.__claudeTeamsSplashEnhancedStartedAt = undefined;
+          splash.remove();
+        }, fadeDuration);
+      };
+
+      const exitTimer = window.setTimeout(() => {
+        avatarReadyTimer = window.setTimeout(dismissSplash, avatarReadyMaxWait);
+        void (scene.ready ?? Promise.resolve()).then(dismissSplash, dismissSplash);
+      }, exitDelay);
+
+      return () => {
+        dismissed = true;
+        window.clearTimeout(exitTimer);
+        if (avatarReadyTimer !== undefined) {
+          window.clearTimeout(avatarReadyTimer);
+        }
+        if (removeTimer !== undefined) {
+          window.clearTimeout(removeTimer);
+        }
+      };
+    }
+
+    return undefined;
+  }, []);
+
+  // Initialize context system lazily when SSH connection state changes.
+  // Local-only users never pay the cost of IndexedDB init + context IPC calls.
+  useEffect(() => {
+    if (!api.ssh?.onStatus) return;
+    const cleanup = api.ssh.onStatus(() => {
+      void useStore.getState().initializeContextSystem();
+      void useStore.getState().fetchAvailableContexts();
+    });
+    return cleanup;
+  }, []);
+
+  return (
+    <ErrorBoundary>
+      <TooltipProvider delayDuration={150} skipDelayDuration={1500}>
+        <ContextSwitchOverlay />
+        <TabbedLayout />
+        <ConfirmDialog />
+        <ToolApprovalSheet />
+      </TooltipProvider>
+    </ErrorBoundary>
+  );
+};