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。

8.6 KB
Raw Blame
import { useCallback, useEffect, useRef, useState } from 'react';
import { useTranslation } from 'react-i18next';

import { toast } from '@/lib/toast';
import { createLogger } from '@/lib/logger';

const log = createLogger('useDiscordBot');
const OWNER_USER_ID_PATTERN = /^\d{17,20}$/;

interface DiscordBotCache {
  ownerUserId: string;
  status: DiscordBotTransportStatus;
  lifecycleAnnouncement: boolean;
}

let cachedState: DiscordBotCache | null = null;

export interface UseDiscordBotReturn {
  token: string;
  setToken: (v: string) => void;
  ownerUserId: string;
  setOwnerUserId: (v: string) => void;
  status: DiscordBotTransportStatus;
  lifecycleAnnouncement: boolean;
  setLifecycleAnnouncement: (enabled: boolean) => void;
  validationError: string | null;
  isSaving: boolean;
  isDisconnecting: boolean;
  canConnect: boolean;
  connect: () => Promise<boolean>;
  reconnect: () => Promise<void>;
  disconnect: () => Promise<void>;
}

export function useDiscordBot(): UseDiscordBotReturn {
  const { t } = useTranslation();
  const [token, setTokenState] = useState('');
  const [ownerUserId, setOwnerUserIdState] = useState(() => cachedState?.ownerUserId ?? '');
  const [status, setStatus] = useState<DiscordBotTransportStatus>(
    () => cachedState?.status ?? { kind: 'idle' },
  );
  const [lifecycleAnnouncement, setLifecycleAnnouncementState] = useState(
    () => cachedState?.lifecycleAnnouncement ?? true,
  );
  const [validationError, setValidationError] = useState<string | null>(null);
  const [isSaving, setIsSaving] = useState(false);
  const [isDisconnecting, setIsDisconnecting] = useState(false);
  const lifecycleRequestVersionRef = useRef(0);
  const statusVersionRef = useRef(0);
  const latestStatusRef = useRef(status);

  useEffect(() => {
    let cancelled = false;
    const lifecycleReadVersion = lifecycleRequestVersionRef.current;
    void (async () => {
      try {
        const state = await window.electronAPI.discordBot.getStatus();
        if (cancelled) return;
        const nextOwnerUserId = state.ownerUserId ?? '';
        const nextLifecycleAnnouncement = state.lifecycleAnnouncement !== false;
        const lifecycleReadIsCurrent = lifecycleReadVersion === lifecycleRequestVersionRef.current;
        setStatus(state.status);
        setOwnerUserIdState(nextOwnerUserId);
        if (lifecycleReadIsCurrent) {
          setLifecycleAnnouncementState(nextLifecycleAnnouncement);
        }
        cachedState = {
          ownerUserId: nextOwnerUserId,
          status: state.status,
          lifecycleAnnouncement: lifecycleReadIsCurrent
            ? nextLifecycleAnnouncement
            : (cachedState?.lifecycleAnnouncement ?? true),
        };
      } catch (err) {
        const msg = err instanceof Error ? err.message : String(err);
        log.error('getStatus failed:', msg);
      }
    })();
    return () => {
      cancelled = true;
    };
  }, []);

  useEffect(() => {
    const unsub = window.electronAPI.discordBot.onStatusChange((update) => {
      statusVersionRef.current += 1;
      latestStatusRef.current = update.status;
      setStatus(update.status);
      cachedState = {
        ownerUserId: cachedState?.ownerUserId ?? '',
        status: update.status,
        lifecycleAnnouncement: cachedState?.lifecycleAnnouncement ?? true,
      };
    });
    return unsub;
  }, []);

  const setToken = useCallback((v: string) => {
    setTokenState(v);
    setValidationError(null);
  }, []);

  const setOwnerUserId = useCallback((v: string) => {
    setOwnerUserIdState(v);
    setValidationError(null);
  }, []);

  const setLifecycleAnnouncement = useCallback((enabled: boolean) => {
    const previous = lifecycleAnnouncement;
    const requestVersion = ++lifecycleRequestVersionRef.current;
    setLifecycleAnnouncementState(enabled);
    cachedState = {
      ownerUserId: cachedState?.ownerUserId ?? '',
      status: cachedState?.status ?? { kind: 'idle' },
      lifecycleAnnouncement: enabled,
    };
    void window.electronAPI.discordBot.setLifecycleAnnouncement(enabled).then((result) => {
      if (requestVersion !== lifecycleRequestVersionRef.current) return;
      if (result.ok && result.lifecycleAnnouncement === enabled) return;
      setLifecycleAnnouncementState(result.lifecycleAnnouncement);
      if (cachedState) {
        cachedState = { ...cachedState, lifecycleAnnouncement: result.lifecycleAnnouncement };
      }
    }).catch((err) => {
      if (requestVersion !== lifecycleRequestVersionRef.current) return;
      const msg = err instanceof Error ? err.message : String(err);
      log.error('setLifecycleAnnouncement failed:', msg);
      setLifecycleAnnouncementState(previous);
      if (cachedState) cachedState = { ...cachedState, lifecycleAnnouncement: previous };
    });
  }, [lifecycleAnnouncement]);

  const connect = useCallback(async () => {
    if (isSaving) return false;
    const trimmedToken = token.trim();
    const trimmedOwnerUserId = ownerUserId.trim();

    if (!trimmedToken || !trimmedOwnerUserId) {
      setValidationError(t('logic.validation.discordFieldsRequired'));
      return false;
    }
    if (!OWNER_USER_ID_PATTERN.test(trimmedOwnerUserId)) {
      setValidationError(t('logic.validation.discordOwnerUserIdFormat'));
      return false;
    }

    setValidationError(null);
    setIsSaving(true);
    try {
      const result = await window.electronAPI.discordBot.setConfig({
        token: trimmedToken,
        ownerUserId: trimmedOwnerUserId,
      });
      const canonicalOwnerUserId = result.ownerUserId ?? '';
      setStatus(result.status);
      setOwnerUserIdState(canonicalOwnerUserId);
      cachedState = {
        ownerUserId: canonicalOwnerUserId,
        status: result.status,
        lifecycleAnnouncement: cachedState?.lifecycleAnnouncement ?? lifecycleAnnouncement,
      };
      if (result.saveErrorStatus?.kind === 'error' || result.status.kind === 'error') {
        toast.error(t('logic.toasts.discordBotConnectFailed'));
        return false;
      }
      toast.success(t('logic.toasts.discordBotConnected'));
      return true;
    } catch (err) {
      const msg = err instanceof Error ? err.message : String(err);
      log.error('setConfig failed:', msg);
      toast.error(t('logic.toasts.discordBotSaveFailed', { message: msg }));
      return false;
    } finally {
      setIsSaving(false);
    }
  }, [isSaving, lifecycleAnnouncement, ownerUserId, t, token]);

  const reconnect = useCallback(async () => {
    if (isSaving || isDisconnecting) return;
    setIsSaving(true);
    setValidationError(null);
    setStatus({ kind: 'connecting' });
    latestStatusRef.current = { kind: 'connecting' };
    const version = statusVersionRef.current;
    try {
      const result = await window.electronAPI.discordBot.reconnect();
      if (version === statusVersionRef.current) {
        setStatus(result.status);
        if (cachedState) cachedState = { ...cachedState, status: result.status };
      }
    } catch (err) {
      log.error('reconnect failed:', err instanceof Error ? err.message : String(err));
      if (version === statusVersionRef.current || latestStatusRef.current.kind === 'connecting') {
        const failed: DiscordBotTransportStatus = {
          kind: 'error', reason: t('logic.toasts.discordBotConnectFailed'),
        };
        setStatus(failed);
        if (cachedState) cachedState = { ...cachedState, status: failed };
      }
    } finally {
      setIsSaving(false);
    }
  }, [isSaving, isDisconnecting, t]);

  const disconnect = useCallback(async () => {
    if (isDisconnecting) return;
    setIsDisconnecting(true);
    try {
      const result = await window.electronAPI.discordBot.disconnect();
      setStatus(result.status);
      setOwnerUserIdState('');
      setTokenState('');
      setValidationError(null);
      cachedState = {
        ownerUserId: '',
        status: result.status,
        lifecycleAnnouncement: cachedState?.lifecycleAnnouncement ?? lifecycleAnnouncement,
      };
      toast.success(t('logic.toasts.discordBotDisconnected'));
    } catch (err) {
      const msg = err instanceof Error ? err.message : String(err);
      log.error('disconnect failed:', msg);
      toast.error(t('logic.toasts.discordBotDisconnectFailed', { message: msg }));
    } finally {
      setIsDisconnecting(false);
    }
  }, [isDisconnecting, lifecycleAnnouncement, t]);

  const canConnect =
    token.trim().length > 0 &&
    OWNER_USER_ID_PATTERN.test(ownerUserId.trim()) &&
    !isSaving &&
    !isDisconnecting;

  return {
    token,
    setToken,
    ownerUserId,
    setOwnerUserId,
    status,
    lifecycleAnnouncement,
    setLifecycleAnnouncement,
    validationError,
    isSaving,
    isDisconnecting,
    canConnect,
    connect,
    reconnect,
    disconnect,
  };
}