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。

19.0 KB
Raw Blame
/**
 * useSessionLifecycleActions — 会话 archive / delete / unarchive 的共享副作用序列
 * ---------------------------------------------------------------------------
 * 两个消费方(PR #64 合并留言里的 TODO(unify)):
 *   - CCAgentSidebarUpper:会话列表右键菜单 / 行内 archive 快捷按钮
 *   - SessionContentHeader:右栏顶栏 ··· 菜单
 *
 * 本 hook 封装乐观补丁、预检、写库与收尾。前置检查(IM 接管拦截)和确认弹窗
 * 由调用方通过 prepareArchive 提供;运行态判据由本 hook 统一提供,
 * 调用方在关闭共享前复用,执行层在异步等待后复核。归档入口共用可等待的
 * confirmDialog,确认文案与是否需要确认仍由各入口按预检结果决定。
 *
 * activeSessionId 表示调用方原先浏览的会话;归档跳转前还会读取实时路由,
 * 防止预检或确认期间切换任务后,旧操作把新页面带走。
 *
 * 远程(device-link)任务的归档 / 恢复走 remoteProjectsStore 的状态迁移叠加层,与本机
 * sessionsStore 状态事务对称:行当帧换桶,写库成功后落被控端返回的行,失败回滚。
 * 远程预检通过 prepareArchive 在乐观换桶之后执行;取消或失败恢复行,确认后才跳离详情。
 *
 * includeArchived 必须与调用方自己的 useCCSessions 桶一致:unarchive 的 refreshSessions
 * 只刷当前桶,sidebar 处于 archived / all 桶时删除行后若刷的是默认 active
 * 桶,已删行会在当前列表残留(Codex review P2)。header 始终展示 active
 * 会话语境,用默认值即可。
 */

import { useCallback } from 'react';
import { flushSync } from 'react-dom';
import { useSidebarNavigate } from '../sidebar/sidebarNavigation';
import { isSessionRemovalRouteCurrent } from '../lib/sessionRemovalNavigation';
import { useTranslation } from 'react-i18next';

import { toast } from '@/lib/toast';
import * as sessionService from '@/lib/sessionService';
import { makerChatStore } from '@/lib/makerChatStore';
import { discardDraft as discardComposerDraft } from '@/lib/composerDraftStore';
import { cleanupSessionLayoutPrefs } from '@/lib/sessionLayoutPrefs';
import { sessionsStore, type SessionStatusTransitionToken } from '@/lib/sessionsStore';
import { useCCSessions } from '@/hooks/useCCSessions';
import {
  remoteProjectsStore,
  type RemotePendingStatusToken,
} from '@/features/device-link/remoteProjectsStore';
import {
  getRemoteSessionActivity,
  isRemoteSessionActivityActive,
} from '@/features/device-link/remoteSessionActivityStore';
import { createLogger } from '@/lib/logger';
import type { ListStatusFilter } from '@/lib/sessionService';
import type { Session, SessionStatus } from '@/lib/ccAgent.types';

const log = createLogger('useSessionLifecycleActions');

/**
 * 远程任务的状态写按会话串行发出(对齐本机 beginStatusTransitionWhenReady、手机
 * sessionMetaWriteQueue):叠加层当帧切换,用户可在「全部」筛选里归档后立刻恢复;两次
 * patch-meta 可能走不同链路(直连 / 中继)逆序到达被控端,较早的意图会最后落库。
 * 前一笔结算(成功或失败)后才发下一笔,被控端按用户操作顺序落库。
 */
const remoteStatusWrites = new Map<string, Promise<Session>>();

function setStatusInOrder(
  sessionId: string,
  status: SessionStatus,
  target: Awaited<ReturnType<typeof sessionService.resolveStatusWriteTarget>>,
): Promise<Session> {
  const write = () => sessionService.setStatus(sessionId, status, target);
  if (target.kind !== 'device-link') return write();
  const previous = remoteStatusWrites.get(sessionId);
  const next = previous ? previous.then(write, write) : write();
  remoteStatusWrites.set(sessionId, next);
  const release = () => {
    if (remoteStatusWrites.get(sessionId) === next) remoteStatusWrites.delete(sessionId);
  };
  next.then(release, release);
  return next;
}

export interface RunSessionActionOptions {
  /** 归档预检与确认。远程任务先乐观换桶,未获确认不写入、不清理或跳离详情。 */
  prepareArchive?: (isCurrent: () => boolean) => Promise<boolean>;
  /** 当前活跃会话 id —— 决定 archive / delete 后是否需要跳走。 */
  activeSessionId: string | null | undefined;
  /**
   * 删除当前会话后的明确跳转目标。侧边栏会基于用户当前可见行顺序传入
   * "下一条 / 上一条 / 新建";没有列表上下文的入口继续回落到 /cc-agent。
   */
  deleteRedirectRoute?: string | null;
}

export function useSessionLifecycleActions(options?: { includeArchived?: ListStatusFilter }) {
  const navigate = useSidebarNavigate();
  const { t } = useTranslation();
  // patchLocal / refreshSessions 转发到 sessionsStore 模块级单例,
  // 与调用方组件里的 useCCSessions 实例共享同一份 cache。
  // includeArchived 跟随调用方的桶(见文件头注释)。
  const { refreshSessions, patchLocal } = useCCSessions(options);
  // 取成 string 再进 deps —— options 是调用方每次渲染新建的字面量对象,直接放进
  // runSessionAction 的 deps 会让它每次重建,打穿 sidebar 的行 handler memo
  // (行渲染隔离不变量,见 SessionItem.tsx)。
  const listFilter: ListStatusFilter = options?.includeArchived ?? 'active';

  // Read stores at the side-effect boundary, never the render-time running set.
  const archiveBlockedByRunning = useCallback((sessionId: string, deviceId?: string | null) => {
    const running = makerChatStore.getRunningSnapshot().get(sessionId)?.isRunning ||
      (deviceId && isRemoteSessionActivityActive(getRemoteSessionActivity(sessionId, deviceId)));
    if (running) toast.warning(t('ccAgent.sidebar.archiveBlocked.running'));
    return Boolean(running);
  }, [t]);

  /**
   * 远程任务归档的乐观起点:叠加层把行移出 active 桶,并按 runSessionAction 同一顺序
   * 跳离(行留在列表时先跳再换桶,否则先换桶再跳,理由见下方 archive 段注释)。
   * 只在已确认的 runSessionAction 内开始,返回凭据供写库成功或失败时结算。
   */
  const beginRemoteArchive = useCallback(
    (
      sessionId: string,
      deviceId: string,
      activeSessionId: string | null | undefined,
    ): RemotePendingStatusToken => {
      const archivedRowStaysInList = listFilter === 'all';
      const leaveArchivedSession = () => {
        if (sessionId === activeSessionId && isSessionRemovalRouteCurrent(sessionId)) {
          navigate('/cc-agent/new');
        }
      };
      if (archivedRowStaysInList) flushSync(leaveArchivedSession);
      let token!: RemotePendingStatusToken;
      flushSync(() => {
        token = remoteProjectsStore.beginPendingStatus(deviceId, sessionId, 'archived');
      });
      if (!archivedRowStaysInList) leaveArchivedSession();
      return token;
    },
    [navigate, listFilter],
  );

  /**
   * archive / delete 实际执行序列。不关心确认弹窗的开合状态——由调用方负责。
   */
  const runSessionAction = useCallback(
    async (
      sessionId: string,
      action: 'delete' | 'archive',
      { activeSessionId, deleteRedirectRoute, prepareArchive }: RunSessionActionOptions,
    ) => {
      const actionStartedAt = performance.now();
      const targetStatus: SessionStatus = action === 'delete' ? 'deleted' : 'archived';
      const statusWriteTarget = await sessionService.resolveStatusWriteTarget(sessionId);
      const isDeviceLinkSession = statusWriteTarget.kind === 'device-link';
      // Preflight/confirmation and write-target resolution may outlive the initial running check.
      const deviceId = statusWriteTarget.kind === 'device-link' ? statusWriteTarget.deviceId : undefined;
      if (action === 'archive' && archiveBlockedByRunning(sessionId, deviceId)) return;
      let statusTransition: SessionStatusTransitionToken | null = null;
      // device-link 远程会话:status 写经隧道(setStatus 内部按来源路由 patch-meta)。归档走
      // remoteProjectsStore 的状态迁移叠加层乐观换桶,写库成功即落被控端返回的行,不等
      // sessions:patched 回流。
      let remoteStatus: RemotePendingStatusToken | null = null;

      if (action === 'archive' && prepareArchive) {
        if (isDeviceLinkSession) {
          remoteStatus = beginRemoteArchive(sessionId, statusWriteTarget.deviceId, null);
        }
        try {
          const confirmed = await prepareArchive(
            () => !remoteStatus || remoteProjectsStore.isPendingStatusCurrent(remoteStatus),
          );
          if (!confirmed || archiveBlockedByRunning(sessionId, deviceId)) {
            if (remoteStatus) remoteProjectsStore.rollbackPendingStatus(remoteStatus);
            return;
          }
          // 恢复、删除或设备移除已经取代了本次意图时,迟到预检不能再发归档。
          if (remoteStatus && !remoteProjectsStore.isPendingStatusCurrent(remoteStatus)) return;
        } catch (err) {
          if (remoteStatus) remoteProjectsStore.rollbackPendingStatus(remoteStatus);
          log.error('[archive preparation]', err);
          toast.error(t('ccAgent.sidebar.archiveFailed'));
          return;
        }
      }

      if (action === 'archive' && isDeviceLinkSession) {
        if (!remoteStatus) {
          remoteStatus = beginRemoteArchive(sessionId, statusWriteTarget.deviceId, activeSessionId);
        } else if (sessionId === activeSessionId && isSessionRemovalRouteCurrent(sessionId)) {
          navigate('/cc-agent/new');
        }
      } else if (action === 'archive') {
        // 乐观更新的顺序取决于**被归档的行还会不会留在当前列表里**,两种情况相反:
        //
        //   · 会留下(调用方在 'all' 桶):patchLocal 只是把它重排到归档段,行还在。
        //     必须先让 navigate commit + paint 掉 isActive 高亮,再重排,否则会看到
        //     "那行被归档后还在新位置短暂高亮"。两次独立 flushSync 就是为这个。
        //   · 会消失(active 桶,最常见):store 已经把它从桶里就地移除,高亮随行一起
        //     消失,不存在残留问题。这时**不能**让 navigate 先跑 —— flushSync 里的
        //     navigate 要同步渲染整个主视图切换(卸下会话视图、挂上新建页),那一帧
        //     几十毫秒全堵在"行消失"之前。改成先 flushSync 掉行(只重渲染 sidebar,
        //     便宜),navigate 不加 flushSync 让它排到后面的帧。
        //
        // 乐观更新还**依赖 sessionsStore.patchLocal 就地移除、不 drop 桶**:早期 store
        // 对跨桶迁移一律 drop + 重拉,桶变 null 会让 useCCSessions 跳过 setState,
        // 本段全部白做,行要等 sessions:list 回来(数百毫秒)才消失。改 store 那段
        // 逻辑前先看它的 patchLocal 注释。
        //
        // 借鉴 Codex 的 onArchivedCurrentThread 思路 navigate 到 /cc-agent/new
        // 空白态,而不是 /cc-agent 让 CCAgentIndexRedirect 挑下一条 —— 后者会按
        // 启发式跳到任意 session,sidebar 高亮"无规律地跳到某行",跟鼠标位置无关。
        //
        // Delete 仍走原来的"先 DB 后清理"流程:delete 不可逆,乐观删除如果 DB 失
        // 败会让用户看到"行消失又出现"的诡异闪烁,代价比 archive 大。写库成功
        // 后再用 patchLocal 从所有桶移除。
        const archivedRowStaysInList = listFilter === 'all';
        const leaveArchivedSession = () => {
          if (sessionId === activeSessionId && isSessionRemovalRouteCurrent(sessionId)) {
            navigate('/cc-agent/new');
          }
        };
        statusTransition = await sessionsStore.beginStatusTransitionWhenReady(
          sessionId,
          {
            status: 'archived',
            pinnedAt: null,
          },
          (begin) => {
            // A previous local status write can keep us waiting after the check above.
            if (archiveBlockedByRunning(sessionId, deviceId)) return null;
            if (archivedRowStaysInList) flushSync(leaveArchivedSession);
            let transition: SessionStatusTransitionToken | null = null;
            flushSync(() => {
              transition = begin();
            });
            return transition;
          },
        );
        if (!statusTransition) return;
        if (!archivedRowStaysInList) {
          leaveArchivedSession();
        }
      }

      // 关子进程:排在乐观更新之后 —— 它只是 fire-and-forget 地通知 main 收掉 SDK
      // query,不影响列表,没有理由挤在用户等着看到行消失的那一段前面。
      makerChatStore.closeSessionQuery(sessionId);

      const statusWriteStartedAt = performance.now();
      let statusWriteFinishedAt = statusWriteStartedAt;
      let persisted: Session;
      try {
        // setStatus 按来源路由(远程走隧道 set-status,本机走原 update);archive 时
        // handler 内部一并 unpin —— 归档列表里不该再保留 pin 标记。
        persisted = await setStatusInOrder(sessionId, targetStatus, statusWriteTarget);
        statusWriteFinishedAt = performance.now();
        if (statusTransition) {
          sessionsStore.completeStatusTransition(statusTransition, persisted);
        }
        if (remoteStatus) remoteProjectsStore.completePendingStatus(remoteStatus, persisted);
      } catch (err) {
        log.error('[session action]', err);
        if (statusTransition) sessionsStore.rollbackStatusTransition(statusTransition);
        if (remoteStatus) remoteProjectsStore.rollbackPendingStatus(remoteStatus);
        if (action === 'archive') {
          const failedAt = performance.now();
          log.warn('archive timing', {
            event: 'renderer.session.archive.timing',
            outcome: 'failed',
            sessionId,
            deviceLink: isDeviceLinkSession,
            preWriteMs: Math.round(statusWriteStartedAt - actionStartedAt),
            writeMs: Math.round(failedAt - statusWriteStartedAt),
            totalMs: Math.round(failedAt - actionStartedAt),
          });
        }
        toast.error(
          action === 'delete'
            ? t('ccAgent.sidebar.deleteFailed')
            : t('ccAgent.sidebar.archiveFailed'),
        );
        return;
      }
      const statusConvergedAt = performance.now();

      if (action === 'delete' && !isDeviceLinkSession) {
        // DB 已确认删除成功后再让 sessionsStore 修正所有已加载的筛选桶。
        // 仅刷新当前桶会留下陈旧的 active / all 缓存,切换筛选时已删除会话会短暂重现;
        // 不在写库前乐观移除,避免失败时出现“先消失、再恢复”的反向闪烁。
        patchLocal(sessionId, persisted);
      }

      // MEM-1: Free all in-memory state (messages, base64 images, listeners)
      // for the deleted/archived session now that the server update succeeded.
      makerChatStore.purgeSession(sessionId);
      // composer-draft-per-session: drop any leftover composer draft (text /
      // attachments) for this session — without this the draft Map would
      // hold an orphan entry forever.
      discardComposerDraft(sessionId);
      if (action === 'delete') {
        void window.electronAPI.cleanupSessionImages(sessionId).catch((err: unknown) => {
          log.warn('[session delete] cleanup images failed', err);
        });
        // RSB 布局偏好(fraction / treeWidth / collapsed)按 sessionId 持久化在
        // localStorage,删 session 时一起清掉,避免僵尸数据堆积。
        cleanupSessionLayoutPrefs(sessionId);
      }
      if (action === 'archive') {
        const finishedAt = performance.now();
        log.info('archive timing', {
          event: 'renderer.session.archive.timing',
          outcome: 'success',
          sessionId,
          deviceLink: isDeviceLinkSession,
          preWriteMs: Math.round(statusWriteStartedAt - actionStartedAt),
          writeMs: Math.round(statusWriteFinishedAt - statusWriteStartedAt),
          convergeMs: Math.round(statusConvergedAt - statusWriteFinishedAt),
          cleanupMs: Math.round(finishedAt - statusConvergedAt),
          totalMs: Math.round(finishedAt - actionStartedAt),
        });
      }

      // sessionsStore 已用任一缓存桶中的完整 row 同步迁移 active / archived / all;
      // 完全找不到 row 时也只合并补查目标桶。这里不再发全局 refresh,避免连续归档
      // 把每次状态写放大成所有已加载桶的一轮 fresh 查询。
      // 远程归档已由叠加层换桶并落了写库返回的行;远程删除仍由被控端 sessions:patched{status}
      // 回流(applyPatch 移出分片)驱动,控制端不主动重拉 / 不埋「主动移除」标记(掉线 vs 删除的
      // 区分见 CCAgentSessionView 优雅退出)。

      // Archive 已在前面乐观跳到 /cc-agent/new,这里只处理 delete。调用方有列表
      // 上下文时会传入按当前可见顺序解析好的 route;否则回落到 /cc-agent
      // 让 CCAgentIndexRedirect 做默认恢复。
      if (action === 'delete' && sessionId === activeSessionId) {
        navigate(deleteRedirectRoute ?? '/cc-agent');
      }
    },
    [navigate, patchLocal, listFilter, beginRemoteArchive, archiveBlockedByRunning, t],
  );

  /**
   * unarchive:archive 的反向状态事务,不弹确认。若归档仍在写库,先等它收敛,
   * 再以完整归档行作为恢复失败时的回滚基线。远程任务同样乐观换桶(叠加层),
   * 写库成功后释放归档墓碑,被控端后续 patch 不再被丢弃、也不必等 reseed。
   */
  const unarchiveSession = useCallback(
    async (sessionId: string) => {
      const statusWriteTarget = await sessionService.resolveStatusWriteTarget(sessionId);
      const isDeviceLinkSession = statusWriteTarget.kind === 'device-link';
      const statusTransition = isDeviceLinkSession
        ? null
        : await sessionsStore.beginStatusTransitionWhenReady(sessionId, { status: 'active' });
      if (!isDeviceLinkSession && !statusTransition) return;
      const remoteStatus = isDeviceLinkSession
        ? remoteProjectsStore.beginPendingStatus(statusWriteTarget.deviceId, sessionId, 'active')
        : null;
      try {
        const persisted = await setStatusInOrder(sessionId, 'active', statusWriteTarget);
        if (statusTransition) {
          sessionsStore.completeStatusTransition(statusTransition, persisted);
        }
        if (remoteStatus) {
          makerChatStore.releaseRemoteArchivedTombstone(sessionId, remoteStatus.deviceId);
          remoteProjectsStore.completePendingStatus(remoteStatus, persisted);
        }
      } catch (err) {
        log.error('[session unarchive]', err);
        if (statusTransition) sessionsStore.rollbackStatusTransition(statusTransition);
        if (remoteStatus) remoteProjectsStore.rollbackPendingStatus(remoteStatus);
        toast.error(t('ccAgent.sidebar.unarchiveFailed'));
        if (!statusTransition && !isDeviceLinkSession) await refreshSessions();
        return;
      }
    },
    [refreshSessions, t],
  );

  return { runSessionAction, unarchiveSession, archiveBlockedByRunning };
}