Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

30.9 KB
Raw Blame
/**
 * HookWorkspacePrefsEditor —— 工作目录卡片内嵌的会话偏好编辑行。
 *
 * 由 HookConnectionsSection 在每个目录卡片下渲染(用户反馈: 偏好属于目录
 * 条目本身, 不该是独立区块): agent / 模型(含思考强度) / 权限模式三个字段。
 *
 * **两个控件一律复用应用标准选择器,本文件不自建任何选择 UI**(2026-07 用户
 * 定稿: 这里曾私搭一套裸下拉, 露出 'claude-code' 原始 id、自己拼一遍可选模型
 * 清单、effort 直接显示未经 i18n 的 low/medium/high):
 *   - Harness 与模型由 ModelSelector 一次提交, 不保留独立引擎控件。
 *   - 模型    -> ModelSelector 的 field trigger, **composer 同款全功能形态**(供应商
 *                分段/订阅来源/推理强度全开; 2026-07 用户定稿基准: 全软件一个模型
 *                选择面板, 处处同行为, 差异只有样式)。来源落本地
 *                workspaceProviderSourceStore, model/effort 照旧走 server prefs
 *   - 权限    -> PermissionSelector 的 field trigger
 * 思考强度不再是独立控件 —— 它并进模型 trigger 显示成「模型名 · 档位」, 与
 * 隔壁 ImDefaultSettingsSection(IM 新会话默认)和会话输入框成一套。
 *
 * 未显式设置的字段**解析出当前真正会生效的默认值**直接展示, 界面上不暴露
 * 「默认」概念(无后缀 / 无弱化色 / 无「恢复默认」菜单项 —— 用户反馈: 不要
 * 有 xxx(默认)这种); 选中任一项即写显式偏好。解析链与 main 侧 defaults.ts
 * 逐字段对齐(resolveEffectiveRow, 纯函数有单测), 数据源是 imDefaultSettingsGet
 * (**频道随 provider**: Slack 读 channels.slack, Telegram 读 global, 与派发侧
 * session-runner 同源)+ 本机 capabilities。权限档另经
 * resolveEffectivePermissionMode 校准: 无显式偏好 → bypassPermissions(无人值守
 * 历史默认), 显式档不被当前 agent 支持 → 该 agent 最严档(绝不放宽)。
 *
 * 数据正本在本机 hook-workspace-prefs.json。设置页离线可读可写;连上后
 * 镜像到 hook server,只供 /model 卡展示和遥控。卡片在线改动经推送写回本机。
 * 写入的联动校准仍走 hookWorkspacePrefsLogic.ts。
 *
 * 状态模型(禁用整体置灰而非增删行, 规则 7):
 *   - 开关未开 / 未绑定 -> 禁用 + 对应提示
 *   - 已绑定但 hook 掉线 -> 仍可编辑, 提示改动保存在本机
 * 颜色一律走主题 token(规则 16)。
 */

import { useModelPickerAgents } from '@/hooks/useAvailableAgents';
import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from 'react';
import { useTranslation } from 'react-i18next';

import { cn } from '@/lib/utils';
import { toast } from '@/lib/toast';
import { extractIpcError } from '@/utils/ipcError';
import { useAgentCapabilities, type AgentCapabilities } from '@/hooks/useAgentCapabilities';
import { ModelSelector } from '@/components/new-chat/ModelSelector';
import { useProviderShareAgentDevices } from '@/features/provider-share/useProviderShareAgentDevices';
import { agentDeviceModelMemoryAccessors } from '@/state/agentDeviceModelMemory';
import { PermissionSelector } from '@/components/new-chat/PermissionSelector';
import type { MakerVendor } from '@/lib/ccAgent.types';
import {
  getProviderModelEffort,
  setProviderModelChoice,
  setProviderModelEffort,
  getProviderModelFast,
  setProviderModelFast,
} from '@/state/providerModelMemory';
import type {
  HookPrefsPatch,
  HookPrefsView,
  HookWorkspacePrefs,
  HookWorkspaceProviderSourceEntry,
  ProviderPrefsView,
  SlackHookView,
} from '../../../shared/hookControlIpc';
import type { ImDefaultSettingsState } from '../../../shared/imDefaultSettings';
import {
  AGENT_KINDS,
  HOOK_DEFAULT_PERMISSION_MODE,
  isKnownAgent,
  patchForModelChange,
  resolveEffectiveRow,
  type ImDefaultsLike,
  type KnownAgent,
  type PrefsAgentCaps,
} from './hookWorkspacePrefsLogic';

/** 全 null 的缺省偏好行(该目录从未设置过)。 */
function emptyPrefs(workspace: string): HookWorkspacePrefs {
  return { workspace, model: null, effort: null, agentKind: null, permissionMode: null };
}

function toPrefsCaps(caps: AgentCapabilities | null): PrefsAgentCaps | null {
  if (caps === null) return null;
  return {
    models: caps.availableModels.map((m) => ({
      id: m.id,
      efforts: m.efforts,
      defaultEffort: m.defaultEffort,
    })),
    permissionModes: caps.permissionModes.map((pm) => ({ id: pm.id })),
  };
}

export interface HookWorkspacePrefsState {
  /** 按别名查该目录偏好(无行返回全 null 缺省; multi-team 下按选中 team 过滤)。 */
  prefsFor: (alias: string) => HookWorkspacePrefs;
  /** 目录显式来源优先,否则继承当前引擎的 IM 默认来源。 */
  providerSourceFor: (alias: string) => string | null;
  agentDeviceFor: (alias: string) => string | null;
  /** 写/清该目录的模型来源偏好(providerId = null 清除)。 */
  applyProviderSource: (alias: string, providerId: string | null, agentDeviceId?: string | null) => Promise<boolean>;
  /** 是否可编辑(已连接 + 已绑定 + 快照可用)。 */
  editable: boolean;
  /** 写入在途的目录别名(该卡片下拉禁用)。 */
  pendingWs: string | null;
  /** 不可编辑的原因提示(null = 无需提示); 宿主渲染一次。 */
  hint: string | null;
  /** hint 为「服务器过旧」时提供的重试入口(其余为 null)。 */
  retry: (() => void) | null;
  /** 桌面新会话默认设置(解析「当前生效默认值」的数据源; 未就绪为 null)。 */
  imDefaults: ImDefaultsLike | null;
  /** 重新拉取 imDefaults(存量 global override 被清掉后刷新目录行的生效值)。 */
  reloadImDefaults: () => Promise<void>;
  /** alsoProviderSource: 远端写成功后串联落本地来源(undefined = 不动来源)。 */
  applyPatch: (
    workspace: string,
    patch: HookPrefsPatch,
    alsoProviderSource?: string | null,
    agentDeviceId?: string | null,
  ) => Promise<boolean>;
  /** (multi-team)可用绑定清单(未 displaced); 单绑定/老 server 时 ≤1 条。 */
  teams: Array<{ teamId: string; teamName: string | null }>;
  /** 当前偏好归属 team(teams 非空时必有值; 选中项失效自动回落首个)。 */
  selectedTeamId: string | null;
  selectTeam: (teamId: string) => void;
  /** 是否显示 team 切换 chip(server multi-team 且 ≥2 个可用绑定)。 */
  showTeamChip: boolean;
}

export type HookPrefsProvider = 'slack' | 'telegram' | 'x';

/** provider-neutral prefs 线(Telegram / X): 走 provider.bind/prefs 帧, 绑定按 bindingId 归属。 */
type NeutralPrefsProvider = Exclude<HookPrefsProvider, 'slack'>;
function isNeutralPrefsProvider(provider: HookPrefsProvider): provider is NeutralPrefsProvider {
  return provider !== 'slack';
}

function isProviderPrefsView(view: HookPrefsView | ProviderPrefsView): view is ProviderPrefsView {
  return 'provider' in view;
}

/**
 * 目录偏好共享状态(单订阅): 拉取/写入/推送同步 + 禁用态归纳。
 * hook 传 null 时(数据未就绪)一切禁用无提示。
 */
export function useHookWorkspacePrefs(
  hook: SlackHookView | null,
  provider: HookPrefsProvider = 'slack',
): HookWorkspacePrefsState {
  const { t } = useTranslation();
  const [prefsView, setPrefsView] = useState<HookPrefsView | ProviderPrefsView | null>(null);
  /** 'unavailable' = 快照读不到(server 太旧 / 通道缺失 / 内部错), 提示 + 重试。 */
  const [loadError, setLoadError] = useState<'unavailable' | null>(null);
  const [pendingWs, setPendingWs] = useState<string | null>(null);
  const [imDefaults, setImDefaults] = useState<ImDefaultsLike | null>(null);
  // 目录模型来源偏好(纯本地文件, 不经 WS): 全量条目一次拉取, 写后用返回值刷新。
  const [providerSources, setProviderSources] = useState<HookWorkspaceProviderSourceEntry[]>([]);
  // latest-wins 守卫(Copilot review): 快速连选/跨窗口广播时, 较慢的旧回复不得覆盖新状态。
  const providerSourceRevisionRef = useRef(0);
  /**
   * 拉一次「新会话默认设置」(目录行未显式设置字段的生效值解析源)。
   * 单独抽出来是因为存量 global override 被清掉后要能立刻刷新生效值 —— 否则目录行
   * 会继续显示已经不再生效的旧默认。
   */
  const fetchImDefaults = useCallback(async (): Promise<void> => {
    try {
      const state: ImDefaultSettingsState = await window.electronAPI.maker.imDefaultSettingsGet(
        provider === 'slack' ? 'slack' : undefined,
      );
      setImDefaults({ agentKind: state.agentKind, agents: state.agents });
    } catch {
      /* 读不到就保持上一份(解析退回内置默认), 不影响目录行其它字段 */
    }
  }, [provider]);

  const neutral = isNeutralPrefsProvider(provider);
  const neutralView = neutral && hook !== null ? hook[provider as NeutralPrefsProvider] : null;
  const neutralBindingId =
    neutralView?.binding?.state === 'confirmed' ? neutralView.binding.bindingId : null;
  const enabled = neutral ? neutralView?.enabled === true : hook?.enabled === true;
  const connected = neutral
    ? enabled && Boolean(neutralView?.available) && neutralView?.status === 'connected'
    : enabled && hook?.status === 'connected';
  const providerBindingConfirmed = !neutral || neutralView?.binding?.state === 'confirmed';
  // 本机正本不依赖 WS:已绑定即可拉本地快照。未绑定仍不发起(避免空身份)。
  const readyIdentity = providerBindingConfirmed
    ? neutral
      ? neutralBindingId === null
        ? null
        : `${provider}:${neutralBindingId}`
      : enabled
        ? 'slack'
        : null
    : null;
  // Initialised to null (never a real identity) so the ready-edge effect below
  // is the single fetch trigger: it performs the first fetch on mount only when
  // the provider is actually reachable, and cannot double-fetch with a separate
  // mount effect (issue #279 review).
  const lastReadyIdentityRef = useRef<string | null>(null);
  const fetchRevisionRef = useRef(0);
  const mutationRevisionRef = useRef(0);
  const neutralBindingIdRef = useRef<string | null>(neutralBindingId);
  neutralBindingIdRef.current = neutralBindingId;

  const fetchPrefs = useCallback(async () => {
    const revision = ++fetchRevisionRef.current;
    try {
      const res = isNeutralPrefsProvider(provider)
        ? await window.electronAPI.hookControl.getProviderWorkspacePrefs(provider)
        : await window.electronAPI.hookControl.getWorkspacePrefs();
      if (revision !== fetchRevisionRef.current) return;
      const nextPrefs: HookPrefsView | ProviderPrefsView = res.prefs;
      if (
        isNeutralPrefsProvider(provider) &&
        (!isProviderPrefsView(nextPrefs) ||
          nextPrefs.provider !== provider ||
          nextPrefs.bindingId !== neutralBindingIdRef.current)
      ) {
        return;
      }
      if (provider === 'slack' && isProviderPrefsView(nextPrefs)) return;
      setPrefsView(nextPrefs);
      setLoadError(null);
    } catch (err) {
      if (revision !== fetchRevisionRef.current) return;
      const code = extractIpcError(err)?.code;
      // GET 已改走本机文件, 不应再出现 HOOK_NOT_CONNECTED; 仍静默以免旧桌面误报。
      if (code !== 'HOOK_NOT_CONNECTED') setLoadError('unavailable');
    }
  }, [provider]);

  useEffect(() => {
    let active = true;
    const applyIncoming = (view: HookPrefsView | ProviderPrefsView) => {
      if (isNeutralPrefsProvider(provider)) {
        if (
          !isProviderPrefsView(view) ||
          view.provider !== provider ||
          view.bindingId !== neutralBindingIdRef.current
        ) {
          return;
        }
      } else if (isProviderPrefsView(view)) {
        return;
      }
      // /model 卡改动 / 其它窗口写入的实时同步(全量快照 latest-wins)
      fetchRevisionRef.current += 1;
      setPrefsView(view);
      setLoadError(null);
    };
    const offPrefs = isNeutralPrefsProvider(provider)
      ? window.electronAPI.hookControl.onProviderPrefsChanged((view) => {
          if (view.provider === provider) applyIncoming(view);
        })
      : window.electronAPI.hookControl.onPrefsChanged(applyIncoming);
    // The ready-edge effect below performs the initial prefs fetch (only when
    // reachable). The subscription set up here just needs to exist first so no
    // server push is missed before that fetch resolves.
    // 桌面新会话默认设置: 未显式设置字段的生效值解析源, 面板打开时取一次即可。
    // **频道必须与派发侧同源**: session-runner 用
    // `readImDefaultSettings(sourceIm === 'slack' ? 'slack' : undefined)` —— Slack 读
    // channels.slack, 官方 Telegram 读 global;个人 Telegram Bot 才读
    // channels.telegram。这里必须与官方派发侧同源,否则目录行会显示一套默认值、
    // 实际会话却使用另一套。
    void fetchImDefaults();
    // 初次拉取同样受 latest-wins 守卫(Copilot review): 回复未归时若已收到其它
    // 窗口的写入广播(revision 已前进), 旧快照不得回滚新状态。
    const initialSourcesRevision = providerSourceRevisionRef.current;
    void window.electronAPI.hookControl
      .getWorkspaceProviderSources()
      .then((res) => {
        if (active && providerSourceRevisionRef.current === initialSourcesRevision) {
          setProviderSources(res.entries);
        }
      })
      .catch(() => {});
    // 多窗口同步(codex review): 会话副窗也能开设置页, 其它窗口写入时以广播的
    // 全量条目为准刷新(与 prefs.state 的 latest-wins 快照语义一致)。
    const offProviderSources = window.electronAPI.hookControl.onWorkspaceProviderSourcesChanged(
      (entries) => {
        providerSourceRevisionRef.current += 1;
        setProviderSources(entries);
      },
    );
    return () => {
      active = false;
      fetchRevisionRef.current += 1;
      mutationRevisionRef.current += 1;
      offPrefs();
      offProviderSources();
    };
  }, [fetchPrefs, provider]);

  // 唯一的拉取触发点: 初次挂载、断线 -> 重连成功、或 Telegram 绑定身份变化时,
  // 拉取对应 provider 的快照。readyIdentity 为 null(provider 未连接/未绑定)时
  // 不发起无意义的 prefs IPC —— 否则会以 HOOK_NOT_CONNECTED 失败并在 Main 侧
  // 打出误导性的 Slack ERROR(issue #279)。lastReadyIdentityRef 初始为 null,
  // 保证 provider 首次可用即拉取且同一身份不重复触发; 只看布尔 ready 会让 A
  // 换绑 B 时继续展示 A 的偏好。
  useEffect(() => {
    if (readyIdentity !== null && readyIdentity !== lastReadyIdentityRef.current) {
      void fetchPrefs();
    }
    lastReadyIdentityRef.current = readyIdentity;
  }, [readyIdentity, fetchPrefs]);

  // (multi-team)偏好归属 team: 可选清单 = 未 displaced 的绑定; 选中项失效
  // (解绑/被顶)时自动回落首个, 不留悬空选择
  // 离线冷启动 welcome 还没回来时 serverMultiTeam 是 false,但 bindings
  // 缓存已经能区分 multi-team。有未 displaced 行就按多绑定写 teamId,
  // 避免离线改动落成 null 行、重连后无法镜像到对应 workspace。
  const multiTeam =
    provider === 'slack' &&
    (hook?.serverMultiTeam === true || (hook?.bindings ?? []).some((b) => !b.displaced));
  const teams = useMemo(
    () =>
      (provider === 'slack' ? (hook?.bindings ?? []) : [])
        .filter((b) => !b.displaced)
        .map((b) => ({ teamId: b.teamId, teamName: b.teamName })),
    [hook, provider],
  );
  const [selectedTeamRaw, setSelectedTeamRaw] = useState<string | null>(null);
  const selectedTeamId = teams.some((tm) => tm.teamId === selectedTeamRaw)
    ? selectedTeamRaw
    : (teams[0]?.teamId ?? null);
  const activePrefsView: HookPrefsView | ProviderPrefsView | null = neutral
    ? prefsView !== null &&
      isProviderPrefsView(prefsView) &&
      prefsView.provider === provider &&
      prefsView.bindingId === neutralBindingId
      ? prefsView
      : null
    : prefsView !== null && !isProviderPrefsView(prefsView)
      ? prefsView
      : null;

  const prefsFor = useCallback(
    (alias: string): HookWorkspacePrefs => {
      const entries = activePrefsView?.prefs ?? [];
      if (multiTeam && selectedTeamId !== null) {
        // 精确 team 匹配优先; 老 server 存量行(无 teamId)宽松兜底
        return (
          entries.find((e) => e.workspace === alias && (e.teamId ?? null) === selectedTeamId) ??
          entries.find((e) => e.workspace === alias && (e.teamId ?? null) === null) ??
          emptyPrefs(alias)
        );
      }
      return entries.find((e) => e.workspace === alias) ?? emptyPrefs(alias);
    },
    [activePrefsView, multiTeam, selectedTeamId],
  );

  // 与派发端同口径:有目录来源时整组覆盖(缺省位置表示明确选本机),
  // 无目录来源才继承该引擎的默认来源及执行位置,不能逐字段混用。
  const providerRouteFor = useCallback((alias: string) => {
    const teamId = multiTeam ? selectedTeamId : null;
    const entry = providerSources.find((e) => e.channel === provider && e.teamId === teamId && e.workspace === alias)
      ?? providerSources.find((e) => e.channel === provider && e.teamId === null && e.workspace === alias);
    if (entry) return entry;
    const agentKind = prefsFor(alias).agentKind;
    return imDefaults?.agents[isKnownAgent(agentKind) ? agentKind : imDefaults.agentKind] ?? null;
  }, [providerSources, provider, multiTeam, selectedTeamId, prefsFor, imDefaults]);
  const providerSourceFor = useCallback((alias: string): string | null =>
    providerRouteFor(alias)?.providerId ?? null, [providerRouteFor]);
  const agentDeviceFor = useCallback((alias: string): string | null =>
    providerRouteFor(alias)?.agentDeviceId ?? null, [providerRouteFor]);

  const applyProviderSource = useCallback(
    (alias: string, providerId: string | null, agentDeviceId?: string | null) => {
      const teamId = multiTeam ? selectedTeamId : null;
      const revision = ++providerSourceRevisionRef.current;
      return window.electronAPI.hookControl
        .setWorkspaceProviderSource({ channel: provider, teamId, workspace: alias, providerId,
          ...(agentDeviceId !== undefined ? { agentDeviceId } : {}) })
        .then((res) => {
          if (revision === providerSourceRevisionRef.current) setProviderSources(res.entries);
          return true;
        })
        .catch((err: unknown) => {
          if (revision === providerSourceRevisionRef.current) {
            toast.error(extractIpcError(err)?.message ?? t('settings.tina.prefs.toast.saveFailed'));
          }
          return false;
        });
    },
    [provider, multiTeam, selectedTeamId, t],
  );

  const applyPatch = useCallback(
    // alsoProviderSource(可选): 远端 model/effort 写**成功后**再落本地来源 ——
    // 两个持久面串联而非并行(Greptile/codex review: 并行 fire-and-forget 会在
    // 一半失败时留下「新来源配旧模型」的分裂态)。顺序选「先远端后本地」:远端
    // 失败 → 整体失败, 来源不动, 状态与操作前一致;本地失败(概率远小)→ 旧来源
    // 配新模型, 派发端校验不通过时拒绝新任务并提示重新选择模型(显式来源不换账号)。
    (workspace: string, patch: HookPrefsPatch, alsoProviderSource?: string | null, agentDeviceId?: string | null) => {
      // A server push, binding change, retry, or newer mutation must win over
      // this response. Otherwise a delayed set reply can roll the UI back to
      // an older provider snapshot and clear another mutation's pending state.
      const revision = ++fetchRevisionRef.current;
      const mutationRevision = ++mutationRevisionRef.current;
      setPendingWs(workspace);
      const request = isNeutralPrefsProvider(provider)
        ? window.electronAPI.hookControl.setProviderWorkspacePrefs(provider, workspace, patch)
        : window.electronAPI.hookControl.setWorkspacePrefs(
            workspace,
            patch,
            multiTeam ? selectedTeamId : undefined,
          );
      return request
        .then(async (res) => {
          // 来源落地在快照守卫**之前**(codex review): invoke 成功 = 远端已确认
          // 本次 (model, effort) 写入 —— 这一事实不因「更新的快照先到」而失效;
          // 守卫只管下方 UI 快照是否回填,若来源也被守卫跳过(prefs 回执经广播
          // 先到的正常时序), 会留下「新模型 + 旧来源」的持久分裂。
          if (alsoProviderSource !== undefined) {
            if (!await applyProviderSource(workspace, alsoProviderSource, agentDeviceId)) return false;
          }
          if (revision !== fetchRevisionRef.current) return true;
          const nextPrefs: HookPrefsView | ProviderPrefsView = res.prefs;
          if (
            isNeutralPrefsProvider(provider) &&
            (!isProviderPrefsView(nextPrefs) ||
              nextPrefs.provider !== provider ||
              nextPrefs.bindingId !== neutralBindingIdRef.current)
          ) {
            return true;
          }
          if (provider === 'slack' && isProviderPrefsView(nextPrefs)) return true;
          fetchRevisionRef.current += 1;
          setPrefsView(nextPrefs);
          setLoadError(null);
          return true;
        })
        .catch((err: unknown) => {
          if (revision !== fetchRevisionRef.current) return false;
          const ipcErr = extractIpcError(err);
          if (ipcErr?.code === 'HOOK_PREFS_TIMEOUT') setLoadError('unavailable');
          toast.error(ipcErr?.message ?? t('settings.tina.prefs.toast.saveFailed'));
          void fetchPrefs();
          return false;
        })
        .finally(() => {
          if (mutationRevision === mutationRevisionRef.current) setPendingWs(null);
        });
    },
    [fetchPrefs, t, multiTeam, provider, selectedTeamId, applyProviderSource],
  );

  const bound = providerBindingConfirmed && activePrefsView?.bound === true;
  const providerLabel = t(
    provider === 'telegram'
      ? 'settings.tina.prefs.providerTelegram'
      : provider === 'x'
        ? 'settings.tina.prefs.providerX'
        : 'settings.tina.prefs.providerSlack',
  );
  const hint = loadError === 'unavailable'
    ? t('settings.tina.prefs.serverUnsupported')
    : !providerBindingConfirmed || (activePrefsView !== null && !bound)
      ? t('settings.tina.prefs.requireBinding', { provider: providerLabel })
      : !connected
        ? t('settings.tina.prefs.offlineLocal', { provider: providerLabel })
        : null;

  return {
    prefsFor,
    providerSourceFor,
    agentDeviceFor,
    applyProviderSource,
    editable: Boolean(enabled) && bound && loadError === null,
    pendingWs,
    hint,
    retry: loadError === 'unavailable' ? () => void fetchPrefs() : null,
    imDefaults,
    reloadImDefaults: fetchImDefaults,
    applyPatch,
    teams,
    selectedTeamId,
    selectTeam: setSelectedTeamRaw,
    showTeamChip: multiTeam && teams.length > 1,
  };
}

/** 字段外框:标题 + 控件,三个字段共用,保证 label 排版一致。 */
function PrefsField({
  label,
  className,
  children,
}: {
  label: string;
  className?: string;
  children: ReactNode;
}) {
  return (
    <div className={cn('flex min-w-0 flex-col gap-1', className)}>
      <span className="text-11 text-[var(--text-tertiary)]">{label}</span>
      {children}
    </div>
  );
}

/** hook prefs 的 agentKind → 选择器的 vendor key。 */
function toVendorKey(agentKind: string | null): 'cc' | 'codex' | 'pi' {
  return agentKind === 'codex' || agentKind === 'pi' ? agentKind : 'cc';
}

/** 目录卡片内的偏好编辑行(完整模型配置 / 权限)。alias 为该行当前生效别名。 */
export function WorkspacePrefsEditor({
  alias,
  state,
  maxVisibleModelRows,
}: {
  alias: string;
  state: HookWorkspacePrefsState;
  maxVisibleModelRows?: number;
}) {
  const { t } = useTranslation();
  const agentDeviceId = state.agentDeviceFor(alias);
  const sharedDevices = useProviderShareAgentDevices([agentDeviceId]);
  const claudeCaps = useAgentCapabilities('claude-code', agentDeviceId ?? undefined);
  const codexCaps = useAgentCapabilities('codex', agentDeviceId ?? undefined);
  const piCaps = useAgentCapabilities('pi', agentDeviceId ?? undefined);
  const capsByAgent = useMemo(
    () =>
      ({
        'claude-code': claudeCaps.capabilities,
        codex: codexCaps.capabilities,
        pi: piCaps.capabilities,
      }) as Record<KnownAgent, AgentCapabilities | null>,
    [claudeCaps.capabilities, codexCaps.capabilities, piCaps.capabilities],
  );
  const capsOf = useCallback(
    (agentKind: string): AgentCapabilities | null =>
      AGENT_KINDS.includes(agentKind as KnownAgent) ? capsByAgent[agentKind as KnownAgent] : null,
    [capsByAgent],
  );

  const prefs = state.prefsFor(alias);
  const eff = resolveEffectiveRow(prefs, state.imDefaults, (k) => toPrefsCaps(capsOf(k)));
  const effAgentCaps = capsOf(eff.agentKind.id ?? '');
  const disabled = !state.editable || state.pendingWs === alias;
  const vendorKey = toVendorKey(eff.agentKind.id);

  const pickerAgents = useModelPickerAgents(vendorKey === 'cc' ? 'claude-code' : vendorKey === 'pi' ? 'pi' : 'codex', agentDeviceId);

  /** 落一个模型选择(分段行与 flat 行共用): 随手写入 (agent, model) 配对并校准 effort。 */
  const applyModel = (next: string) => {
    if (next === prefs.model || eff.agentKind.id === null) return;
    return state.applyPatch(
      alias,
      patchForModelChange(eff.agentKind.id, next, prefs, toPrefsCaps(effAgentCaps)),
    );
  };

  return (
    <div className="flex flex-wrap items-end gap-2">
      {/* 模型 + 思考强度同一个控件, **composer 同款全功能标准面板**(2026-07 用户
          定稿基准: 全软件一个模型选择面板, 处处同行为, 差异只有样式):供应商分段、
          订阅来源、推理强度全开。来源(providerId)是纯客户端维度, 落本地
          workspaceProviderSourceStore; model/effort 照旧走 server prefs 通道
          (Slack /model 卡展示不受影响)。派发侧按 (来源, 模型) 经
          effectiveSourceIdForModel 校验: 显式来源失效时拒绝而不换账号; 目录模型
          跟随默认时, 不提供该模型的残留来源被忽略(issue #5912), 不会拼出不可能
          路由 —— 「选 A 落 B」的根因(选了来源没地方存)已消除。 */}
      <PrefsField label={t('settings.tina.prefs.modelLabel')} className="flex-1 basis-[220px]">
        <ModelSelector
          remoteAgent={{ devices: sharedDevices.devices, selectedDeviceId: agentDeviceId }}
          fastModeConfigurable={false}
          unifiedAgents={pickerAgents}
          onUnifiedSelect={({ engine, modelId, providerId, effort, agentDevice }) => state.applyPatch(
            alias,
            { agentKind: engine === 'cc' ? 'claude-code' : engine, model: modelId, effort: effort || null },
            providerId,
            agentDevice?.deviceId ?? null,
          )}
          modelId={eff.model.id ?? ''}
          effort={eff.effort.id ?? ''}
          vendorKey={vendorKey}
          triggerVariant="field"
          popoverSide="bottom"
          maxVisibleModelRows={maxVisibleModelRows}
          dense
          // 可及名上下文与 agent 分段同规则(字段名 · 行别名),多卡片同屏读屏可区分。
          ariaContext={`${t('settings.tina.prefs.modelLabel')} · ${alias}`}
          // 当前 Harness 的能力加载失败也能改选其它可用 Harness。
          disabled={disabled}
          // 这一行的 modelId 可能是**解析出来的继承值**(prefs.model 为 null 时来自 IM
          // 新会话默认), 点它的语义是「把继承值钉成本目录的显式偏好」, 必须照常回调 ——
          // 否则用户点了没反应, 之后上游默认一变这条偏好就被静默改掉。
          reselectEmitsChange
          // 已存模型不在可见清单(被隐藏 / 供应商断开 / 目录下架)时显示裸 id 而非
          // 「选择模型」占位符: 占位符会把「存过但当前不可用」显示成「没选过」, 用户
          // 既看不到自己存的是什么、也无从判断为何 bot 用的不是它。与本组件接管前
          // (PrefsSelect 的 modelLabel 回落裸 id)行为一致; 派发侧另有回落并记日志。
          unknownModelLabel={(id) => id}
          // 非选中行 hover 配置(推理强度/Fast)与 composer 共用同一份模型级全局预设。
          modelMemory={agentDeviceId ? agentDeviceModelMemoryAccessors(agentDeviceId) : {
            getEffort: getProviderModelEffort,
            setEffort: setProviderModelEffort,
            setChoice: setProviderModelChoice,
            getFast: getProviderModelFast,
            setFast: setProviderModelFast,
          }}
          currentProviderId={state.providerSourceFor(alias)}
          // 分段行原子选择:model/effort 走远端 prefs,成功后来源落本地(串联,
          // 见 applyPatch 的 alsoProviderSource 注释)。目标行的 provider-specific
          // effort 由共享 ModelSelector 回传;旧调用方未提供时才回落本地记忆。
          onProviderChange={(providerId, modelId, reconciledEffort) => {
            if (eff.agentKind.id === null) return false;
            const caps = toPrefsCaps(effAgentCaps);
            if (modelId) {
              const patch = patchForModelChange(eff.agentKind.id, modelId, prefs, caps);
              if (reconciledEffort !== undefined) {
                patch.effort = reconciledEffort || null;
              } else {
                const remembered =
                  providerId && isKnownAgent(eff.agentKind.id)
                    ? getProviderModelEffort(eff.agentKind.id, providerId, modelId)
                    : undefined;
                if (
                  remembered &&
                  caps?.models.find((m) => m.id === modelId)?.efforts.includes(remembered)
                ) {
                  patch.effort = remembered;
                }
              }
              return state.applyPatch(alias, patch, providerId, agentDeviceId);
            } else {
              void state.applyProviderSource(alias, providerId, agentDeviceId);
            }
          }}
          onModelChange={applyModel}
          onEffortChange={(next) => {
            if (next !== prefs.effort) return state.applyPatch(alias, { effort: next });
          }}
        />
      </PrefsField>
      <PrefsField label={t('settings.tina.prefs.permissionLabel')} className="basis-[160px]">
        <PermissionSelector
          permissionMode={eff.permissionMode.id ?? HOOK_DEFAULT_PERMISSION_MODE}
          vendorKey={vendorKey}
          triggerVariant="field"
          dense
          // 可及名上下文与 agent 分段同规则(字段名 · 行别名),多卡片同屏读屏可区分。
          ariaContext={`${t('settings.tina.prefs.permissionLabel')} · ${alias}`}
          disabled={disabled || effAgentCaps === null}
          onPermissionModeChange={(next) => {
            if (next !== prefs.permissionMode) state.applyPatch(alias, { permissionMode: next });
          }}
        />
      </PrefsField>
    </div>
  );
}