@yancyyu/openhermit 1.5.8

package/src/renderer/components/team/dialogs/AddMemberDialog.tsx

@@ -0,0 +1,222 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+
+import { getNextSuggestedMemberName } from '@renderer/components/team/members/memberNameSets';
+import {
+  buildMembersFromDrafts,
+  createMemberDraft,
+  MembersEditorSection,
+  validateMemberNameInline,
+} from '@renderer/components/team/members/MembersEditorSection';
+import { Button } from '@renderer/components/ui/button';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@renderer/components/ui/dialog';
+import { useStore } from '@renderer/store';
+import { CANONICAL_LEAD_MEMBER_NAME, isLeadMemberName } from '@shared/utils/leadDetection';
+import { Loader2 } from 'lucide-react';
+
+import type { MemberDraft } from '@renderer/components/team/members/membersEditorTypes';
+import type { EffortLevel, TeamProviderId } from '@shared/types';
+
+export interface AddMemberEntry {
+  name: string;
+  role?: string;
+  workflow?: string;
+  isolation?: 'worktree';
+  providerId?: TeamProviderId;
+  model?: string;
+  effort?: EffortLevel;
+}
+
+interface AddMemberDialogProps {
+  open: boolean;
+  teamName: string;
+  existingNames: string[];
+  onClose: () => void;
+  /** Called with the list of new members to add. */
+  onAdd: (members: AddMemberEntry[]) => void;
+  adding?: boolean;
+  /** Project path for @file mentions in workflow field. */
+  projectPath?: string | null;
+  /** Existing team members with their colors — used so new drafts get the next available color */
+  existingMembers?: readonly {
+    name: string;
+    color?: string;
+    isolation?: 'worktree';
+    removedAt?: number | string | null;
+  }[];
+}
+
+const DIALOG_WIDTH = 'w-[720px]';
+
+function deriveExistingWorktreeDefault(
+  existingMembers: AddMemberDialogProps['existingMembers']
+): boolean {
+  const activeTeammates =
+    existingMembers?.filter((member) => {
+      const name = member.name.trim().toLowerCase();
+      return !member.removedAt && !isLeadMemberName(name);
+    }) ?? [];
+  return (
+    activeTeammates.length > 0 && activeTeammates.every((member) => member.isolation === 'worktree')
+  );
+}
+
+function buildInitialDrafts(existingNames: string[], worktreeDefault = false): MemberDraft[] {
+  const suggestedName = getNextSuggestedMemberName(existingNames);
+  return [
+    createMemberDraft({
+      name: suggestedName,
+      isolation: worktreeDefault ? 'worktree' : undefined,
+    }),
+  ];
+}
+
+export const AddMemberDialog = ({
+  open,
+  teamName,
+  existingNames,
+  onClose,
+  onAdd,
+  adding,
+  projectPath,
+  existingMembers,
+}: AddMemberDialogProps): React.JSX.Element => {
+  const existingWorktreeDefault = deriveExistingWorktreeDefault(existingMembers);
+  const [teammateWorktreeDefault, setTeammateWorktreeDefault] = useState(existingWorktreeDefault);
+  const [members, setMembers] = useState<MemberDraft[]>(() =>
+    buildInitialDrafts(existingNames, existingWorktreeDefault)
+  );
+  const [error, setError] = useState<string | null>(null);
+  const wasOpenRef = useRef(open);
+  const teamDisplayName = useStore((s) => s.teamByName[teamName]?.displayName || teamName);
+
+  // Combine existing names + names already in the draft list for duplicate validation
+  const allNames = useMemo(() => {
+    const draftNames = members.map((m) => m.name.trim().toLowerCase()).filter(Boolean);
+    return [...existingNames.map((n) => n.toLowerCase()), ...draftNames];
+  }, [existingNames, members]);
+
+  const validateName = useCallback(
+    (name: string): string | null => {
+      const trimmed = name.trim().toLowerCase();
+      if (!trimmed) return null;
+
+      const inlineError = validateMemberNameInline(name);
+      if (inlineError) return inlineError;
+
+      if (trimmed === 'user' || isLeadMemberName(trimmed))
+        return `Name "${CANONICAL_LEAD_MEMBER_NAME}" is reserved`;
+
+      // Check against existing team members
+      if (existingNames.some((n) => n.toLowerCase() === trimmed)) return 'Name is already taken';
+
+      // Check for duplicates within the draft list
+      const draftOccurrences = members.filter(
+        (m) => m.name.trim().toLowerCase() === trimmed
+      ).length;
+      if (draftOccurrences > 1) return 'Duplicate name in the list';
+
+      return null;
+    },
+    [existingNames, members]
+  );
+
+  const hasValidMembers = useMemo(() => {
+    const valid = members.filter((m) => {
+      const name = m.name.trim();
+      return name.length > 0 && !validateName(name);
+    });
+    return valid.length > 0;
+  }, [members, validateName]);
+
+  const handleSubmit = (): void => {
+    const built = buildMembersFromDrafts(members);
+    // Validate all entries
+    const invalid = built.find((m) => validateName(m.name));
+    if (invalid) {
+      setError(validateName(invalid.name));
+      return;
+    }
+    if (built.length === 0) {
+      setError('Add at least one member');
+      return;
+    }
+    setError(null);
+    onAdd(
+      built.map((m) => ({
+        name: m.name,
+        role: m.role,
+        workflow: m.workflow,
+        isolation: m.isolation,
+        providerId: m.providerId,
+        model: m.model,
+        effort: m.effort,
+      }))
+    );
+  };
+
+  const handleOpenChange = (nextOpen: boolean): void => {
+    if (!nextOpen) {
+      setMembers(buildInitialDrafts(existingNames, teammateWorktreeDefault));
+      setError(null);
+      onClose();
+    }
+  };
+
+  useEffect(() => {
+    const wasOpen = wasOpenRef.current;
+    if (open && !wasOpen) {
+      setTeammateWorktreeDefault(existingWorktreeDefault);
+      setMembers(buildInitialDrafts(existingNames, existingWorktreeDefault));
+      setError(null);
+    }
+    wasOpenRef.current = open;
+  }, [existingNames, existingWorktreeDefault, open]);
+
+  const memberCount = members.filter((m) => m.name.trim() && !validateName(m.name)).length;
+
+  return (
+    <Dialog open={open} onOpenChange={handleOpenChange}>
+      <DialogContent className={`${DIALOG_WIDTH} max-w-[90vw]`}>
+        <DialogHeader>
+          <DialogTitle>添加成员</DialogTitle>
+          <DialogDescription>向 {teamDisplayName} 添加新成员</DialogDescription>
+        </DialogHeader>
+
+        <div className="max-h-[60vh] overflow-y-auto py-2">
+          <MembersEditorSection
+            members={members}
+            onChange={setMembers}
+            fieldError={error ?? undefined}
+            validateMemberName={validateName}
+            showWorkflow
+            showJsonEditor={false}
+            draftKeyPrefix={`addMember:${teamName}`}
+            projectPath={projectPath}
+            existingMembers={existingMembers}
+            disableGeminiOption={true}
+            showWorktreeIsolationControls
+            teammateWorktreeDefault={teammateWorktreeDefault}
+            onTeammateWorktreeDefaultChange={setTeammateWorktreeDefault}
+          />
+        </div>
+
+        <DialogFooter>
+          <Button type="button" variant="outline" onClick={onClose} disabled={adding}>
+            取消
+          </Button>
+          <Button type="button" disabled={adding || !hasValidMembers} onClick={handleSubmit}>
+            {adding ? <Loader2 className="mr-1.5 size-4 animate-spin" /> : null}
+            {memberCount > 1 ? `添加 ${memberCount} 名成员` : '添加成员'}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+};

package/src/renderer/components/team/dialogs/AdvancedCliSection.tsx

@@ -0,0 +1,347 @@
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { api } from '@renderer/api';
+import { Button } from '@renderer/components/ui/button';
+import { Checkbox } from '@renderer/components/ui/checkbox';
+import { Input } from '@renderer/components/ui/input';
+import { Label } from '@renderer/components/ui/label';
+import { Popover, PopoverAnchor, PopoverContent } from '@renderer/components/ui/popover';
+import { parseCliArgs, PROTECTED_CLI_FLAGS } from '@shared/utils/cliArgsParser';
+import {
+  AlertTriangle,
+  CheckCircle2,
+  ChevronRight,
+  Clock,
+  Loader2,
+  Terminal,
+  XCircle,
+} from 'lucide-react';
+
+interface AdvancedCliSectionProps {
+  teamName: string;
+  /** All CLI args from parent (model, effort, permissions, resume, etc.) */
+  internalArgs: string[];
+  worktreeEnabled: boolean;
+  onWorktreeEnabledChange: (enabled: boolean) => void;
+  worktreeName: string;
+  onWorktreeNameChange: (name: string) => void;
+  customArgs: string;
+  onCustomArgsChange: (args: string) => void;
+}
+
+/** Infrastructure flags that are dimmed in command preview. */
+const INFRA_FLAGS = new Set([
+  '--input-format',
+  '--output-format',
+  '--setting-sources',
+  '--mcp-config',
+  '--disallowedTools',
+  '--verbose',
+]);
+
+type ValidationState = 'idle' | 'loading' | 'success' | 'error';
+type TokenType = 'command' | 'visible' | 'infra' | 'custom';
+
+/** Map token type → Tailwind color class (pure function, no state dependency). */
+const TOKEN_COLOR_CLASS: Record<TokenType, string> = {
+  command: 'text-text',
+  visible: 'text-text',
+  infra: 'text-text-muted',
+  custom: 'text-emerald-400',
+};
+
+/** Read worktree history from localStorage for a given team. */
+function readWorktreeHistory(teamName: string): string[] {
+  try {
+    const raw = localStorage.getItem(`team:worktreeHistory:${teamName}`);
+    if (!raw) {
+      return [];
+    }
+    const parsed: unknown = JSON.parse(raw);
+    return Array.isArray(parsed)
+      ? parsed.filter((item): item is string => typeof item === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Collapsible "Advanced" section for CreateTeamDialog and LaunchTeamDialog.
+ * Contains: worktree checkbox with history, command preview, custom args + validate.
+ */
+export const AdvancedCliSection: React.FC<AdvancedCliSectionProps> = ({
+  teamName,
+  internalArgs,
+  worktreeEnabled,
+  onWorktreeEnabledChange,
+  worktreeName,
+  onWorktreeNameChange,
+  customArgs,
+  onCustomArgsChange,
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [validationState, setValidationState] = useState<ValidationState>('idle');
+  const [validationMessage, setValidationMessage] = useState<string | null>(null);
+  const [showHistory, setShowHistory] = useState(false);
+
+  // Read worktree history from localStorage; re-read when teamName changes
+  const [worktreeHistory, setWorktreeHistory] = useState<string[]>(() =>
+    readWorktreeHistory(teamName)
+  );
+  useEffect(() => {
+    setWorktreeHistory(readWorktreeHistory(teamName));
+  }, [teamName]);
+
+  // Commit worktree name to history on blur
+  const commitWorktreeName = useCallback(() => {
+    const name = worktreeName.trim();
+    if (!name) return;
+    setWorktreeHistory((prev) => {
+      const next = [name, ...prev.filter((n) => n !== name)].slice(0, 10);
+      localStorage.setItem(`team:worktreeHistory:${teamName}`, JSON.stringify(next));
+      return next;
+    });
+  }, [worktreeName, teamName]);
+
+  // Build command preview tokens
+  const previewTokens = useMemo(() => {
+    const tokens: { text: string; type: 'command' | 'visible' | 'infra' | 'custom' }[] = [];
+    tokens.push({ text: 'claude', type: 'command' });
+
+    // Process internalArgs: classify each as visible or infra
+    let i = 0;
+    while (i < internalArgs.length) {
+      const arg = internalArgs[i];
+      const isInfra = INFRA_FLAGS.has(arg);
+      const type = isInfra ? 'infra' : 'visible';
+      tokens.push({ text: arg, type });
+      // Check if next token is the value for this flag (not starting with --)
+      if (i + 1 < internalArgs.length && !internalArgs[i + 1].startsWith('--')) {
+        tokens.push({ text: internalArgs[i + 1], type });
+        i += 2;
+      } else {
+        i += 1;
+      }
+    }
+
+    // Worktree
+    if (worktreeEnabled && worktreeName.trim()) {
+      tokens.push({ text: '--worktree', type: 'visible' });
+      tokens.push({ text: worktreeName.trim(), type: 'visible' });
+    }
+
+    // Custom args
+    const parsed = parseCliArgs(customArgs);
+    for (const t of parsed) {
+      tokens.push({ text: t, type: 'custom' });
+    }
+
+    return tokens;
+  }, [internalArgs, worktreeEnabled, worktreeName, customArgs]);
+
+  // Validate handler
+  const handleValidate = useCallback(async () => {
+    if (!customArgs.trim()) return;
+    setValidationState('loading');
+    setValidationMessage(null);
+    try {
+      const result = await api.teams.validateCliArgs(customArgs);
+      if (result.valid) {
+        setValidationState('success');
+        setValidationMessage('所有参数有效');
+      } else {
+        setValidationState('error');
+        const flags = result.invalidFlags ?? [];
+        const unknown = flags.filter((f) => !PROTECTED_CLI_FLAGS.has(f));
+        const protectedOnes = flags.filter((f) => PROTECTED_CLI_FLAGS.has(f));
+        const parts: string[] = [];
+        if (unknown.length > 0) parts.push(`未知参数：${unknown.join(', ')}`);
+        if (protectedOnes.length > 0) parts.push(`受保护参数：${protectedOnes.join(', ')}`);
+        setValidationMessage(parts.join(' | '));
+      }
+    } catch (err) {
+      setValidationState('error');
+      setValidationMessage(err instanceof Error ? err.message : '校验失败');
+    }
+  }, [customArgs]);
+
+  // Reset validation when custom args change
+  const handleCustomArgsChange = useCallback(
+    (value: string) => {
+      onCustomArgsChange(value);
+      if (validationState !== 'idle') {
+        setValidationState('idle');
+        setValidationMessage(null);
+      }
+    },
+    [onCustomArgsChange, validationState]
+  );
+
+  const filteredHistory = useMemo(
+    () =>
+      worktreeHistory.filter(
+        (name) => name !== worktreeName && (!worktreeName || name.includes(worktreeName))
+      ),
+    [worktreeHistory, worktreeName]
+  );
+
+  return (
+    <div className="mt-3">
+      {/* Collapsible header */}
+      <button
+        type="button"
+        className="flex items-center gap-1 text-xs text-text-secondary transition-colors hover:text-text"
+        onClick={() => setIsOpen(!isOpen)}
+      >
+        <ChevronRight
+          className={`size-3.5 transition-transform duration-150 ${isOpen ? 'rotate-90' : ''}`}
+        />
+        <Terminal className="size-3" />
+        <span>高级</span>
+      </button>
+
+      {isOpen && (
+        <div className="mt-2 space-y-3 pl-5">
+          {/* Teammate launch mode */}
+          <div className="space-y-1.5">
+            <Label className="text-xs text-text-secondary">成员启动方式</Label>
+            <div className="rounded border border-border bg-surface px-2 py-1.5 text-xs text-text">
+              进程内子 agent
+            </div>
+            <p className="text-[11px] leading-relaxed text-text-muted">
+              成员统一在负责人会话内启动，不再依赖 tmux。成员仍会按顺序逐个启动。
+            </p>
+          </div>
+
+          {/* Worktree */}
+          <div className="space-y-1.5">
+            <div className="flex items-center gap-2">
+              <Checkbox
+                id={`worktree-${teamName}`}
+                checked={worktreeEnabled}
+                onCheckedChange={(value) => onWorktreeEnabledChange(value === true)}
+              />
+              <Label
+                htmlFor={`worktree-${teamName}`}
+                className="cursor-pointer text-xs font-normal text-text-secondary"
+              >
+                使用独立 worktree
+              </Label>
+            </div>
+
+            {worktreeEnabled && (
+              <Popover open={showHistory && filteredHistory.length > 0}>
+                <PopoverAnchor asChild>
+                  <Input
+                    placeholder="worktree-name"
+                    className="h-7 font-mono text-xs"
+                    value={worktreeName}
+                    onChange={(e) => onWorktreeNameChange(e.target.value)}
+                    onFocus={() => setShowHistory(true)}
+                    onBlur={() => {
+                      // Delay to allow click on history items
+                      setTimeout(() => {
+                        setShowHistory(false);
+                        commitWorktreeName();
+                      }, 150);
+                    }}
+                  />
+                </PopoverAnchor>
+                <PopoverContent
+                  className="w-[var(--radix-popover-trigger-width)] p-1"
+                  align="start"
+                  sideOffset={2}
+                  onOpenAutoFocus={(e) => e.preventDefault()}
+                >
+                  <div className="flex items-center gap-1.5 px-2 py-1 text-[10px] text-text-muted">
+                    <Clock className="size-3" />
+                    <span>最近使用</span>
+                  </div>
+                  {filteredHistory.map((name) => (
+                    <button
+                      key={name}
+                      type="button"
+                      className="w-full rounded px-2 py-1 text-left font-mono text-xs text-text-secondary hover:bg-surface-raised hover:text-text"
+                      onMouseDown={(e) => {
+                        e.preventDefault(); // Prevent input blur
+                        onWorktreeNameChange(name);
+                        setShowHistory(false);
+                      }}
+                    >
+                      {name}
+                    </button>
+                  ))}
+                </PopoverContent>
+              </Popover>
+            )}
+          </div>
+
+          {/* Command preview */}
+          <div className="space-y-1">
+            <span className="text-[10px] font-medium uppercase tracking-wider text-text-muted">
+              命令预览
+            </span>
+            <div className="overflow-x-auto rounded border border-border bg-surface-sidebar px-2.5 py-1.5">
+              <code className="flex flex-wrap gap-x-1 gap-y-0.5 font-mono text-[11px] leading-relaxed">
+                {previewTokens.map((token, i) => (
+                  <span key={i} className={TOKEN_COLOR_CLASS[token.type]}>
+                    {token.text}
+                  </span>
+                ))}
+              </code>
+            </div>
+          </div>
+
+          {/* Custom arguments */}
+          <div className="space-y-1.5">
+            <span className="text-[10px] font-medium uppercase tracking-wider text-text-muted">
+              自定义参数
+            </span>
+            <div className="flex items-center gap-2">
+              <Input
+                placeholder="--max-turns 5"
+                className="h-7 flex-1 font-mono text-xs"
+                value={customArgs}
+                onChange={(e) => handleCustomArgsChange(e.target.value)}
+              />
+              {customArgs.trim() && (
+                <Button
+                  type="button"
+                  variant="outline"
+                  size="sm"
+                  className="h-7 px-2.5 text-xs"
+                  disabled={validationState === 'loading'}
+                  onClick={handleValidate}
+                >
+                  {validationState === 'loading' ? (
+                    <Loader2 className="mr-1 size-3 animate-spin" />
+                  ) : null}
+                  校验
+                </Button>
+              )}
+            </div>
+
+            {/* Validation result */}
+            {validationState === 'success' && validationMessage && (
+              <div className="flex items-center gap-1.5 text-xs text-emerald-400">
+                <CheckCircle2 className="size-3" />
+                <span>{validationMessage}</span>
+              </div>
+            )}
+            {validationState === 'error' && validationMessage && (
+              <div className="flex items-start gap-1.5 text-xs">
+                {validationMessage.includes('受保护参数') ? (
+                  <AlertTriangle className="mt-0.5 size-3 shrink-0 text-amber-400" />
+                ) : (
+                  <XCircle className="mt-0.5 size-3 shrink-0 text-red-400" />
+                )}
+                <span className="text-text-secondary">{validationMessage}</span>
+              </div>
+            )}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};

package/src/renderer/components/team/dialogs/AnthropicFastModeSelector.tsx

@@ -0,0 +1,120 @@
+import React, { useMemo } from 'react';
+
+// Stubs for removed anthropic-runtime-profile feature
+function resolveAnthropicRuntimeSelection(_opts: {
+  source: { modelCatalog?: unknown; runtimeCapabilities?: unknown };
+  selectedModel?: string;
+  limitContext: boolean;
+}) {
+  return { fastModeAvailable: false };
+}
+function resolveAnthropicFastMode(_opts: {
+  selection: ReturnType<typeof resolveAnthropicRuntimeSelection>;
+  selectedFastMode: unknown;
+  providerFastModeDefault: boolean;
+}) {
+  return {
+    showFastModeControl: false,
+    resolvedFastMode: false,
+    selectable: false,
+    disabledReason: 'Fast mode is not available.',
+  };
+}
+
+import { Label } from '@renderer/components/ui/label';
+import { useEffectiveCliProviderStatus } from '@renderer/hooks/useEffectiveCliProviderStatus';
+import { cn } from '@renderer/lib/utils';
+import { Zap } from 'lucide-react';
+
+import type { TeamFastMode } from '@shared/types';
+
+export interface AnthropicFastModeSelectorProps {
+  value: TeamFastMode;
+  onValueChange: (value: TeamFastMode) => void;
+  providerFastModeDefault: boolean;
+  model?: string;
+  limitContext: boolean;
+  id?: string;
+}
+
+export const AnthropicFastModeSelector: React.FC<AnthropicFastModeSelectorProps> = ({
+  value,
+  onValueChange,
+  providerFastModeDefault,
+  model,
+  limitContext,
+  id,
+}) => {
+  const { providerStatus } = useEffectiveCliProviderStatus('anthropic');
+
+  const selection = useMemo(
+    () =>
+      resolveAnthropicRuntimeSelection({
+        source: {
+          modelCatalog: providerStatus?.modelCatalog,
+          runtimeCapabilities: providerStatus?.runtimeCapabilities,
+        },
+        selectedModel: model,
+        limitContext,
+      }),
+    [limitContext, model, providerStatus?.modelCatalog, providerStatus?.runtimeCapabilities]
+  );
+
+  const resolution = useMemo(
+    () =>
+      resolveAnthropicFastMode({
+        selection,
+        selectedFastMode: value,
+        providerFastModeDefault,
+      }),
+    [providerFastModeDefault, selection, value]
+  );
+
+  if (!resolution.showFastModeControl) {
+    return null;
+  }
+
+  const defaultLabel = providerFastModeDefault ? '默认（快速）' : '默认（关闭）';
+  const helperText =
+    value === 'inherit'
+      ? `默认当前解析为${resolution.resolvedFastMode ? '快速' : '关闭'}。`
+      : (resolution.disabledReason ??
+        '快速模式由运行时提供，仅当实际启动的 Claude 模型支持时才会启用。');
+
+  return (
+    <div className="mb-3">
+      <Label htmlFor={id} className="label-optional mb-1.5 block">
+        快速模式（可选）
+      </Label>
+      <div className="flex items-center gap-2">
+        <Zap size={16} className="shrink-0 text-[var(--color-text-muted)]" />
+        <div className="inline-flex flex-wrap rounded-md border border-[var(--color-border)] bg-[var(--color-surface)] p-0.5">
+          {[
+            { value: 'inherit' as const, label: defaultLabel, disabled: false },
+            { value: 'on' as const, label: '快速', disabled: !resolution.selectable },
+            { value: 'off' as const, label: '关闭', disabled: false },
+          ].map((option) => (
+            <button
+              key={option.value}
+              type="button"
+              id={option.value === value ? id : undefined}
+              className={cn(
+                'rounded-[3px] px-3 py-1 text-xs font-medium transition-colors',
+                value === option.value
+                  ? 'bg-[var(--color-surface-raised)] text-[var(--color-text)] shadow-sm'
+                  : 'text-[var(--color-text-muted)] hover:text-[var(--color-text-secondary)]',
+                option.disabled &&
+                  'cursor-not-allowed opacity-50 hover:text-[var(--color-text-muted)]'
+              )}
+              disabled={option.disabled}
+              onClick={() => onValueChange(option.value)}
+            >
+              {option.label}
+            </button>
+          ))}
+        </div>
+      </div>
+      <p className="mt-1 text-[11px] text-[var(--color-text-muted)]">{helperText}</p>
+    </div>
+  );
+};