@yancyyu/openhermit 1.5.8

package/src/shared/constants/agentBlocks.ts

@@ -0,0 +1,129 @@
+/**
+ * XML-like marker for agent-only content.
+ * Content wrapped in these markers is intended for the agent (Claude Code)
+ * and should be hidden from the human user in the UI.
+ *
+ * Canonical format:
+ * <info_for_agent>
+ * ... agent-only instructions ...
+ * </info_for_agent>
+ *
+ * Backward compatibility:
+ * - legacy fenced blocks: ```info_for_agent ... ```
+ * - legacy xml-like blocks: <agent-block> ... </agent-block>
+ * - OpenCode runtime-only delivery blocks
+ */
+export const AGENT_BLOCK_TAG = 'info_for_agent';
+export const AGENT_BLOCK_OPEN = `<${AGENT_BLOCK_TAG}>`;
+export const AGENT_BLOCK_CLOSE = `</${AGENT_BLOCK_TAG}>`;
+
+/**
+ * Regex pattern string for matching current and legacy agent-only blocks.
+ */
+const CURRENT_AGENT_BLOCK_PATTERN = '\\n?<info_for_agent>\\n?[\\s\\S]*?\\n?<\\/info_for_agent>\\n?';
+const LEGACY_FENCED_AGENT_BLOCK_PATTERN = '\\n?```' + AGENT_BLOCK_TAG + '\\n[\\s\\S]*?\\n```\\n?';
+const LEGACY_XML_AGENT_BLOCK_PATTERN = '\\n?<agent-block>\\n?[\\s\\S]*?\\n?<\\/agent-block>\\n?';
+const OPENCODE_RUNTIME_IDENTITY_BLOCK_PATTERN =
+  '\\n?<opencode_runtime_identity>\\n?[\\s\\S]*?\\n?<\\/opencode_runtime_identity>\\n?';
+const OPENCODE_APP_MESSAGE_DELIVERY_BLOCK_PATTERN =
+  '\\n?<opencode_app_message_delivery>\\n?[\\s\\S]*?\\n?<\\/opencode_app_message_delivery>\\n?';
+const AGENT_BLOCK_PATTERN = `(?:${CURRENT_AGENT_BLOCK_PATTERN}|${LEGACY_FENCED_AGENT_BLOCK_PATTERN}|${LEGACY_XML_AGENT_BLOCK_PATTERN}|${OPENCODE_RUNTIME_IDENTITY_BLOCK_PATTERN}|${OPENCODE_APP_MESSAGE_DELIVERY_BLOCK_PATTERN})`;
+
+/**
+ * Creates a new RegExp for matching agent blocks.
+ * Returns a fresh instance each time to avoid stateful 'g' flag issues with .test().
+ */
+export function createAgentBlockRegex(): RegExp {
+  return new RegExp(AGENT_BLOCK_PATTERN, 'g');
+}
+
+/**
+ * Removes the current and legacy agent-only blocks from text for UI display.
+ */
+export function stripAgentBlocks(text: string): string {
+  return text
+    .replace(createAgentBlockRegex(), '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+/**
+ * Removes only the wrapper markers from a single agent block.
+ */
+export function unwrapAgentBlock(block: string): string {
+  const trimmed = block.trim();
+
+  if (trimmed.startsWith(AGENT_BLOCK_OPEN) && trimmed.endsWith(AGENT_BLOCK_CLOSE)) {
+    return trimmed.slice(AGENT_BLOCK_OPEN.length, -AGENT_BLOCK_CLOSE.length).trim();
+  }
+
+  const legacyFencedOpen = '```' + AGENT_BLOCK_TAG;
+  if (trimmed.startsWith(legacyFencedOpen) && trimmed.endsWith('```')) {
+    return trimmed.slice(legacyFencedOpen.length, -'```'.length).trim();
+  }
+
+  const legacyXmlOpen = '<agent-block>';
+  const legacyXmlClose = '</agent-block>';
+  if (trimmed.startsWith(legacyXmlOpen) && trimmed.endsWith(legacyXmlClose)) {
+    return trimmed.slice(legacyXmlOpen.length, -legacyXmlClose.length).trim();
+  }
+
+  const opencodeRuntimeOpen = '<opencode_runtime_identity>';
+  const opencodeRuntimeClose = '</opencode_runtime_identity>';
+  if (trimmed.startsWith(opencodeRuntimeOpen) && trimmed.endsWith(opencodeRuntimeClose)) {
+    return trimmed.slice(opencodeRuntimeOpen.length, -opencodeRuntimeClose.length).trim();
+  }
+
+  const opencodeDeliveryOpen = '<opencode_app_message_delivery>';
+  const opencodeDeliveryClose = '</opencode_app_message_delivery>';
+  if (trimmed.startsWith(opencodeDeliveryOpen) && trimmed.endsWith(opencodeDeliveryClose)) {
+    return trimmed.slice(opencodeDeliveryOpen.length, -opencodeDeliveryClose.length).trim();
+  }
+
+  return trimmed;
+}
+
+/**
+ * Extracts agent-only block contents without the wrapper markers.
+ */
+export function extractAgentBlockContents(text: string): string[] {
+  return Array.from(text.matchAll(createAgentBlockRegex()))
+    .map((match) => unwrapAgentBlock(match[0]))
+    .filter((content) => content.length > 0);
+}
+
+/**
+ * @deprecated Use createAgentBlockRegex() instead to avoid stateful 'g' flag issues.
+ * Kept for backward compatibility with .replace() calls.
+ */
+export const AGENT_BLOCK_REGEX = new RegExp(AGENT_BLOCK_PATTERN, 'g');
+
+/**
+ * Wraps text in agent-only block markers.
+ * Use this instead of manually concatenating AGENT_BLOCK_OPEN/CLOSE.
+ */
+export function wrapAgentBlock(text: string): string {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return '';
+  return `${AGENT_BLOCK_OPEN}\n${trimmed}\n${AGENT_BLOCK_CLOSE}`;
+}
+
+/**
+ * Fenced code block marker for reply messages between agents.
+ *
+ * Format:
+ * ```message_reply_for_agent
+ * Reply on @agent-name original message with text "<original>", here is answer: "<reply>"
+ * ```
+ */
+export const MESSAGE_REPLY_TAG = 'message_reply_for_agent';
+export const MESSAGE_REPLY_OPEN = '```' + MESSAGE_REPLY_TAG;
+export const MESSAGE_REPLY_CLOSE = '```';
+
+/**
+ * Creates a new RegExp for matching message reply blocks.
+ * Returns a fresh instance each time to avoid stateful 'g' flag issues with .test().
+ */
+export function createMessageReplyBlockRegex(): RegExp {
+  return new RegExp('```message_reply_for_agent\\n[\\s\\S]*?\\n```', 'g');
+}

package/src/shared/constants/attachments.ts

@@ -0,0 +1,175 @@
+/**
+ * Attachment file categorization and MIME type helpers.
+ *
+ * Browser MIME types are unreliable:
+ *   .ts → "video/mp2t", .json → "application/json", .go/.rs/.yaml → ""
+ * So categorization is ALWAYS by file extension (primary), with browser MIME
+ * used only as a fallback for images.
+ */
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+export const IMAGE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+
+/** Extensions recognized as image files (fallback when browser MIME is empty). */
+const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp']);
+
+/** Extensions recognized as text-based files → sent as `document` block with `text/plain`. */
+export const TEXT_FILE_EXTENSIONS = new Set([
+  // Data
+  'json',
+  'jsonl',
+  'txt',
+  'md',
+  'mdx',
+  'csv',
+  'tsv',
+  // JavaScript / TypeScript
+  'ts',
+  'tsx',
+  'js',
+  'jsx',
+  'mjs',
+  'cjs',
+  // Other languages
+  'py',
+  'go',
+  'rs',
+  'java',
+  'kt',
+  'rb',
+  'c',
+  'h',
+  'cpp',
+  'hpp',
+  'cs',
+  'swift',
+  'dart',
+  'php',
+  'lua',
+  'scala',
+  'ex',
+  'exs',
+  // Web
+  'html',
+  'css',
+  'scss',
+  'less',
+  'vue',
+  'svelte',
+  // Config / markup
+  'xml',
+  'yaml',
+  'yml',
+  'toml',
+  'ini',
+  'cfg',
+  'conf',
+  // Shell
+  'sh',
+  'bash',
+  'zsh',
+  'fish',
+  // Query / schema
+  'sql',
+  'graphql',
+  'gql',
+  'proto',
+  // Misc text
+  'env',
+  'log',
+  'rst',
+  'diff',
+  'patch',
+  // Known filenames that happen to equal their "extension" when split on '.'
+  'dockerfile',
+  'makefile',
+  'gitignore',
+  'dockerignore',
+  'editorconfig',
+]);
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type FileCategory = 'image' | 'pdf' | 'text' | 'unsupported';
+
+// ---------------------------------------------------------------------------
+// Categorization
+// ---------------------------------------------------------------------------
+
+/**
+ * Categorize a `File` by its **extension** (primary) — browser MIME is
+ * unreliable for anything other than images.
+ */
+export function categorizeFile(file: File): FileCategory {
+  // 1. Browser MIME is reliable for images
+  if (IMAGE_MIME_TYPES.has(file.type)) return 'image';
+
+  const ext = file.name.split('.').pop()?.toLowerCase() ?? '';
+
+  // 2. Extension-based checks
+  if (IMAGE_EXTENSIONS.has(ext)) return 'image'; // fallback for empty MIME
+  if (ext === 'pdf') return 'pdf';
+  if (TEXT_FILE_EXTENSIONS.has(ext)) return 'text';
+
+  // 3. Special filenames / patterns
+  const baseName = file.name.toLowerCase();
+  if (baseName.startsWith('.env')) return 'text'; // .env.local, .env.production, etc.
+
+  return 'unsupported';
+}
+
+// ---------------------------------------------------------------------------
+// MIME helpers
+// ---------------------------------------------------------------------------
+
+const IMAGE_EXT_TO_MIME: Record<string, string> = {
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+};
+
+/**
+ * Return the MIME type that should be stored in `AttachmentPayload.mimeType`
+ * (used by the backend to choose the correct content block type).
+ */
+export function getEffectiveMimeType(file: File): string {
+  const cat = categorizeFile(file);
+
+  if (cat === 'image') {
+    if (file.type && IMAGE_MIME_TYPES.has(file.type)) return file.type;
+    // Fallback when browser returns empty MIME for an image extension
+    const ext = file.name.split('.').pop()?.toLowerCase() ?? '';
+    return IMAGE_EXT_TO_MIME[ext] ?? 'image/png';
+  }
+  if (cat === 'pdf') return 'application/pdf';
+  if (cat === 'text') return 'text/plain';
+
+  return file.type || 'application/octet-stream';
+}
+
+// ---------------------------------------------------------------------------
+// MIME type guards (used by backend routing & preview components)
+// ---------------------------------------------------------------------------
+
+export function isImageMime(mime: string): boolean {
+  return IMAGE_MIME_TYPES.has(mime);
+}
+
+export function isPdfMime(mime: string): boolean {
+  return mime === 'application/pdf';
+}
+
+export function isTextDocMime(mime: string): boolean {
+  return mime === 'text/plain';
+}
+
+export function isNativeAttachmentMime(mime: string): boolean {
+  return isImageMime(mime) || isPdfMime(mime) || isTextDocMime(mime);
+}

package/src/shared/constants/cache.ts

@@ -0,0 +1,12 @@
+/**
+ * Cache-related constants.
+ */
+
+/** Maximum number of sessions to cache */
+export const MAX_CACHE_SESSIONS = 5;
+
+/** Cache TTL in minutes */
+export const CACHE_TTL_MINUTES = 5;
+
+/** Cleanup interval in minutes */
+export const CACHE_CLEANUP_INTERVAL_MINUTES = 5;

package/src/shared/constants/cli.ts

@@ -0,0 +1,15 @@
+/**
+ * CLI error message marker.
+ *
+ * All "CLI not found" error messages across main process services MUST
+ * include this substring so the renderer can detect CLI-missing state
+ * without relying on brittle string matching against the full message.
+ */
+export const CLI_NOT_FOUND_MARKER = 'CLI not found';
+
+/**
+ * User-facing message when CLI binary cannot be resolved.
+ * Contains CLI_NOT_FOUND_MARKER so the renderer can detect it.
+ */
+export const CLI_NOT_FOUND_MESSAGE =
+  'CLI not found：未找到 Claude CLI。请确认已安装 Claude Code，或在设置中配置有效的 claude 可执行文件路径。';

package/src/shared/constants/crossTeam.ts

@@ -0,0 +1,126 @@
+// ── Cross-Team Message Protocol ──────────────────────────────────────────────
+// Single source of truth for the cross-team message prefix format.
+// Used by: CrossTeamService (main), crossTeam.js (controller), ActivityItem (renderer), tests.
+
+/** Canonical metadata tag written before stored cross-team message text. */
+export const CROSS_TEAM_TAG_NAME = 'cross-team';
+export const CROSS_TEAM_ATTR_FROM = 'from';
+export const CROSS_TEAM_ATTR_DEPTH = 'depth';
+export const CROSS_TEAM_ATTR_CONVERSATION_ID = 'conversationId';
+export const CROSS_TEAM_ATTR_REPLY_TO_CONVERSATION_ID = 'replyToConversationId';
+export const CROSS_TEAM_PREFIX_TAG = CROSS_TEAM_TAG_NAME;
+
+export interface CrossTeamPrefixMeta {
+  conversationId?: string;
+  replyToConversationId?: string;
+}
+
+export interface ParsedCrossTeamPrefix extends CrossTeamPrefixMeta {
+  from: string;
+  chainDepth: number;
+}
+
+function escapeCrossTeamAttribute(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/"/g, '"')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function unescapeCrossTeamAttribute(value: string): string {
+  return value
+    .replace(/&quot;/g, '"')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+}
+
+function parseCrossTeamAttributes(raw: string): Map<string, string> {
+  const attrs = new Map<string, string>();
+  const matches = raw.matchAll(
+    /* eslint-disable-next-line sonarjs/slow-regex -- attr values bounded by quotes, trusted prefix input */
+    /([A-Za-z][A-Za-z0-9]*)="([^"]*)"/g
+  );
+  for (const match of matches) {
+    const key = match[1]?.trim();
+    const value = match[2];
+    if (!key || value == null) continue;
+    attrs.set(key, unescapeCrossTeamAttribute(value));
+  }
+  return attrs;
+}
+
+/**
+ * Build the full prefix line:
+ * `<cross-team from="team.member" depth="0" conversationId="abc" replyToConversationId="def" />`
+ */
+export function formatCrossTeamPrefix(
+  from: string,
+  chainDepth: number,
+  meta?: CrossTeamPrefixMeta
+): string {
+  const attrs = [
+    `${CROSS_TEAM_ATTR_FROM}="${escapeCrossTeamAttribute(from)}"`,
+    `${CROSS_TEAM_ATTR_DEPTH}="${String(chainDepth)}"`,
+  ];
+  if (meta?.conversationId) {
+    attrs.push(
+      `${CROSS_TEAM_ATTR_CONVERSATION_ID}="${escapeCrossTeamAttribute(meta.conversationId)}"`
+    );
+  }
+  if (meta?.replyToConversationId) {
+    attrs.push(
+      `${CROSS_TEAM_ATTR_REPLY_TO_CONVERSATION_ID}="${escapeCrossTeamAttribute(meta.replyToConversationId)}"`
+    );
+  }
+  return `<${CROSS_TEAM_TAG_NAME} ${attrs.join(' ')} />`;
+}
+
+/** Format the full message text with prefix + body. */
+export function formatCrossTeamText(
+  from: string,
+  chainDepth: number,
+  text: string,
+  meta?: CrossTeamPrefixMeta
+): string {
+  return `${formatCrossTeamPrefix(from, chainDepth, meta)}\n${text}`;
+}
+
+/**
+ * Regex that matches the canonical cross-team metadata tag at the start of a message.
+ */
+export const CROSS_TEAM_PREFIX_RE = new RegExp(
+  `^<${CROSS_TEAM_TAG_NAME}\\s+(?<attrs>[^>]*?)\\s*\\/>\\n?`
+);
+
+/** Parse metadata from a cross-team prefix line. */
+export function parseCrossTeamPrefix(text: string): ParsedCrossTeamPrefix | null {
+  const match = CROSS_TEAM_PREFIX_RE.exec(text);
+  if (!match?.groups) return null;
+
+  const attrs = parseCrossTeamAttributes(match.groups.attrs ?? '');
+  const from = attrs.get(CROSS_TEAM_ATTR_FROM)?.trim();
+  const chainDepth = Number.parseInt(attrs.get(CROSS_TEAM_ATTR_DEPTH) ?? '', 10);
+  if (!from || !Number.isFinite(chainDepth)) return null;
+
+  return {
+    from,
+    chainDepth,
+    conversationId: attrs.get(CROSS_TEAM_ATTR_CONVERSATION_ID)?.trim() || undefined,
+    replyToConversationId: attrs.get(CROSS_TEAM_ATTR_REPLY_TO_CONVERSATION_ID)?.trim() || undefined,
+  };
+}
+
+/** Strip the cross-team prefix from message text (for UI display). */
+export function stripCrossTeamPrefix(text: string): string {
+  return text.replace(CROSS_TEAM_PREFIX_RE, '');
+}
+
+// ── Source discriminators ────────────────────────────────────────────────────
+
+/** Incoming cross-team message (written to target team's inbox). */
+export const CROSS_TEAM_SOURCE = 'cross_team' as const;
+
+/** Outgoing cross-team message copy (written to sender team's inbox). */
+export const CROSS_TEAM_SENT_SOURCE = 'cross_team_sent' as const;

package/src/shared/constants/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared constants barrel export.
+ */
+
+export * from './agentBlocks';
+export * from './attachments';
+export * from './cache';
+export * from './cli';
+export * from './crossTeam';
+export * from './kanban';
+export * from './memberColors';
+export * from './teamLimits';
+export * from './trafficLights';
+export * from './triggerColors';
+export * from './window';

package/src/shared/constants/kanban.ts

@@ -0,0 +1,9 @@
+import type { KanbanColumnId } from '@shared/types';
+
+export const KANBAN_COLUMN_IDS: KanbanColumnId[] = [
+  'todo',
+  'in_progress',
+  'done',
+  'review',
+  'approved',
+];

package/src/shared/constants/memberColors.ts

@@ -0,0 +1,140 @@
+/**
+ * Pre-ordered color palette for team members.
+ * Colors are arranged so that consecutive entries are maximally distant
+ * on the hue wheel — the first N members always get visually distinct colors.
+ * Generated via greedy max-min-distance algorithm over hue angles.
+ * Intentionally excludes purple-family tones.
+ */
+import { CANONICAL_LEAD_MEMBER_NAME } from '@shared/utils/leadDetection';
+
+export const MEMBER_COLOR_PALETTE = [
+  // ── First 12: intentionally distinct visual families for roster readability ──
+  'blue',
+  'saffron',
+  'turquoise',
+  'brick',
+  'indigo',
+  'forest',
+  'apricot',
+  'rose',
+  'cerulean',
+  'olive',
+  'copper',
+  'steel',
+
+  // ── Next 12: secondary accents after the core distinct set ──
+  'gold',
+  'emerald',
+  'cobalt',
+  'crimson',
+  'tangerine',
+  'denim',
+  'cyan',
+  'sage',
+  'tomato',
+  'rust',
+  'mustard',
+  'canary',
+  'teal',
+  'arctic',
+  'royal',
+
+  // ── Remaining: fill the hue gaps progressively ──
+  'green',
+  'pink',
+  'ruby', // 92°
+  'sienna', // 144°
+  'mint', // 216°
+  'sky', // 275°
+  'sapphire', // 321°
+  'yellow', // 13°
+  'red', // 26°
+  'orange', // 33°
+  'coral', // 52°
+  'scarlet', // 65°
+  'salmon', // 79°
+  'amber', // 98°
+  'peach', // 111°
+  'bronze', // 137°
+  'lemon', // 157°
+  'honey', // 170°
+  'marigold', // 183°
+  'sunflower', // 196°
+  'lime', // 209°
+  'jade', // 236°
+  'chartreuse', // 249°
+  'aqua', // 262°
+  'azure', // 281°
+  'seafoam', // 295°
+  'periwinkle', // 327°
+  'cornflower', // 353°
+] as const;
+
+export type MemberColorName = (typeof MEMBER_COLOR_PALETTE)[number];
+
+/**
+ * Canonical runtime/member id for the team lead.
+ * UI surfaces should use this exact key when deriving the lead color so
+ * previews match the resolved team roster.
+ */
+export const TEAM_LEAD_MEMBER_COLOR_ID = CANONICAL_LEAD_MEMBER_NAME;
+
+/**
+ * Fixed hue angle (0-359) for each palette color name.
+ * The first roster-assigned colors are intentionally spaced far apart so the
+ * first 10-12 teammates in a team remain visually distinct.
+ */
+const MEMBER_COLOR_HUES_BY_ORDER = [
+  240, 60, 180, 0, 120, 300, 30, 210, 330, 90, 150, 270, 15, 195, 105, 285, 45, 225, 135, 315, 75,
+  255, 165, 345, 7.5, 187.5, 97.5, 277.5, 37.5, 217.5, 127.5, 307.5, 67.5, 247.5, 157.5, 337.5,
+  22.5, 202.5, 112.5, 292.5, 52.5, 232.5, 142.5, 322.5, 82.5, 262.5, 172.5, 352.5, 11.25, 191.25,
+  101.25, 281.25, 41.25, 221.25, 131.25,
+] as const;
+
+export const MEMBER_COLOR_HUE: Record<string, number> = Object.fromEntries(
+  MEMBER_COLOR_PALETTE.map((colorName, index) => [colorName, MEMBER_COLOR_HUES_BY_ORDER[index]])
+) as Record<string, number>;
+
+const DISALLOWED_MEMBER_COLORS = new Set([
+  'purple',
+  'violet',
+  'plum',
+  'amethyst',
+  'lavender',
+  'orchid',
+  'magenta',
+  'fuchsia',
+  'berry',
+]);
+
+export function getMemberColor(index: number): string {
+  return MEMBER_COLOR_PALETTE[index % MEMBER_COLOR_PALETTE.length];
+}
+
+/**
+ * Simple deterministic hash for a string → non-negative integer.
+ * Uses djb2 algorithm for good distribution across the palette.
+ */
+function hashStringToIndex(str: string): number {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) + hash + str.charCodeAt(i)) | 0;
+  }
+  return Math.abs(hash);
+}
+
+export function normalizeMemberColorName(colorName: string): string {
+  const normalized = colorName.trim().toLowerCase();
+  if (!normalized) return MEMBER_COLOR_PALETTE[0];
+  if (!DISALLOWED_MEMBER_COLORS.has(normalized)) return normalized;
+  return MEMBER_COLOR_PALETTE[hashStringToIndex(normalized) % MEMBER_COLOR_PALETTE.length];
+}
+
+/**
+ * Get a stable color for a member name.
+ * The color is deterministic — same name always maps to the same palette entry,
+ * regardless of member order or team size.
+ */
+export function getMemberColorByName(name: string): string {
+  return MEMBER_COLOR_PALETTE[hashStringToIndex(name) % MEMBER_COLOR_PALETTE.length];
+}

package/src/shared/constants/opencodeTaskLogAttribution.ts

@@ -0,0 +1 @@
+export const OPENCODE_TASK_LOG_ATTRIBUTION_FILE = 'opencode-task-log-attribution.json';

package/src/shared/constants/teamLimits.ts

@@ -0,0 +1,2 @@
+/** Maximum character length for messages and comments in team communication. */
+export const MAX_TEXT_LENGTH = 50_000;

package/src/shared/constants/trafficLights.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared macOS traffic-light geometry.
+ *
+ * Keep this as the single source of truth for both:
+ * - main process native button positioning
+ * - renderer process left padding reservation
+ */
+
+/** IPC event channel emitted by main when zoom changes */
+export const WINDOW_ZOOM_FACTOR_CHANGED_CHANNEL = 'window:zoom-factor-changed';
+
+/** Base traffic-light origin at 100% zoom (native coordinates) */
+const MACOS_TRAFFIC_LIGHT_BASE_POSITION = { x: 12, y: 12 } as const;
+
+/** Header row height used by SidebarHeader and TabBar */
+export const HEADER_ROW1_HEIGHT = 40;
+
+/** Native button-group frame height (used to vertically center in header row) */
+const MACOS_TRAFFIC_LIGHT_GROUP_HEIGHT = 16;
+
+/** Approximate total width of the 3 traffic lights group in native px */
+const MACOS_TRAFFIC_LIGHT_GROUP_WIDTH = 52;
+
+/** Visual gap between traffic lights and first left-aligned content */
+const MACOS_TRAFFIC_LIGHT_CONTENT_GAP = 16;
+
+const MIN_ZOOM_FACTOR = 0.25;
+
+function sanitizeZoomFactor(zoomFactor: number): number {
+  if (!Number.isFinite(zoomFactor) || zoomFactor <= 0) {
+    return 1;
+  }
+  return Math.max(zoomFactor, MIN_ZOOM_FACTOR);
+}
+
+/**
+ * Native traffic-light position for the given zoom.
+ * Uses linear scaling to keep vertical alignment with zoomed title rows.
+ */
+export function getTrafficLightPositionForZoom(
+  zoomFactor: number
+): Readonly<{ x: number; y: number }> {
+  const zoom = sanitizeZoomFactor(zoomFactor);
+  return {
+    x: Math.round(MACOS_TRAFFIC_LIGHT_BASE_POSITION.x * zoom),
+    y: Math.round((HEADER_ROW1_HEIGHT * zoom - MACOS_TRAFFIC_LIGHT_GROUP_HEIGHT) / 2),
+  };
+}
+
+/**
+ * CSS left padding (in CSS px) needed to avoid overlap with native buttons.
+ * Produces a stable physical gap between traffic lights and content at any zoom.
+ */
+export function getTrafficLightPaddingForZoom(zoomFactor: number): number {
+  const zoom = sanitizeZoomFactor(zoomFactor);
+  return Math.ceil(
+    MACOS_TRAFFIC_LIGHT_BASE_POSITION.x +
+      (MACOS_TRAFFIC_LIGHT_GROUP_WIDTH + MACOS_TRAFFIC_LIGHT_CONTENT_GAP) / zoom
+  );
+}