@lobehub/lobehub 2.0.0-next.224 → 2.0.0-next.226

package/src/app/[variants]/(main)/chat/profile/features/Header/AgentPublishButton/useMarketPublish.ts

@@ -3,32 +3,45 @@ import { useCallback, useRef, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { message } from '@/components/AntdStaticMethods';
-import { checkOwnership } from '@/hooks/useAgentOwnershipCheck';
 import { useTokenCount } from '@/hooks/useTokenCount';
 import { useMarketAuth } from '@/layout/AuthProvider/MarketAuth';
-import { marketApiService } from '@/services/marketApi';
+import { lambdaClient } from '@/libs/trpc/client';
 import { useAgentStore } from '@/store/agent';
 import { agentChatConfigSelectors, agentSelectors } from '@/store/agent/selectors';
 import { useGlobalStore } from '@/store/global';
 import { globalGeneralSelectors } from '@/store/global/selectors';
-import { useServerConfigStore } from '@/store/serverConfig';
-import { serverConfigSelectors } from '@/store/serverConfig/selectors';
 
 import type { MarketPublishAction } from './types';
-import { generateDefaultChangelog, generateMarketIdentifier } from './utils';
+import { generateDefaultChangelog } from './utils';
+
+export interface OriginalAgentInfo {
+  author?: {
+    avatar?: string;
+    name?: string;
+    userName?: string;
+  };
+  avatar?: string;
+  identifier: string;
+  name: string;
+}
 
 interface UseMarketPublishOptions {
   action: MarketPublishAction;
   onSuccess?: (identifier: string) => void;
 }
 
+export interface CheckOwnershipResult {
+  needsForkConfirm: boolean;
+  originalAgent: OriginalAgentInfo | null;
+}
+
 export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions) => {
   const { t } = useTranslation('setting');
   const [isPublishing, setIsPublishing] = useState(false);
+  const [isCheckingOwnership, setIsCheckingOwnership] = useState(false);
   // 使用 ref 来同步跟踪发布状态，避免闭包导致的竞态问题
   const isPublishingRef = useRef(false);
-  const { isAuthenticated, session, getCurrentUserInfo } = useMarketAuth();
-  const enableMarketTrustedClient = useServerConfigStore(serverConfigSelectors.enableMarketTrustedClient);
+  const { isAuthenticated } = useMarketAuth();
 
   // Agent data from store
   const meta = useAgentStore(agentSelectors.currentAgentMeta, isEqual);
@@ -46,15 +59,49 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
 
   const isSubmit = action === 'submit';
 
+  /**
+   * Check ownership before publishing
+   * Returns whether fork confirmation is needed and original agent info
+   */
+  const checkOwnership = useCallback(async (): Promise<CheckOwnershipResult> => {
+    const identifier = meta?.marketIdentifier;
+
+    // No identifier means new agent, no need to check
+    if (!identifier) {
+      return { needsForkConfirm: false, originalAgent: null };
+    }
+
+    try {
+      setIsCheckingOwnership(true);
+      const result = await lambdaClient.market.agent.checkOwnership.query({ identifier });
+
+      // If agent doesn't exist or user is owner, no confirmation needed
+      if (!result.exists || result.isOwner) {
+        return { needsForkConfirm: false, originalAgent: null };
+      }
+
+      // User is not owner, need fork confirmation
+      return {
+        needsForkConfirm: true,
+        originalAgent: result.originalAgent as OriginalAgentInfo,
+      };
+    } catch (error) {
+      console.error('[useMarketPublish] Failed to check ownership:', error);
+      // On error, proceed without confirmation
+      return { needsForkConfirm: false, originalAgent: null };
+    } finally {
+      setIsCheckingOwnership(false);
+    }
+  }, [meta?.marketIdentifier]);
+
   const publish = useCallback(async () => {
     // 防止重复发布：使用 ref 同步检查，避免闭包导致的竞态问题
     if (isPublishingRef.current) {
       return { success: false };
     }
 
-    // 如果启用了 trustedClient，只需要检查 isAuthenticated
-    // 因为后端会自动注入 trustedClientToken
-    if (!isAuthenticated || (!enableMarketTrustedClient && !session?.accessToken)) {
+    // 检查认证状态 - tRPC 会自动处理 trustedClient
+    if (!isAuthenticated) {
       return { success: false };
     }
 
@@ -63,8 +110,6 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
       ? t('marketPublish.modal.loading.submit')
       : t('marketPublish.modal.loading.upload');
 
-    let identifier = meta?.marketIdentifier;
-
     const changelog = generateDefaultChangelog();
 
     try {
@@ -72,61 +117,9 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
       isPublishingRef.current = true;
       setIsPublishing(true);
       message.loading({ content: loadingMessage, key: messageKey });
-      // 只有在非 trustedClient 模式下才需要设置 accessToken
-      if (session?.accessToken) {
-        marketApiService.setAccessToken(session.accessToken);
-      }
-
-      // 判断是否需要创建新 agent
-      let needsCreateAgent = false;
-
-      if (!identifier) {
-        // 没有 marketIdentifier，需要创建新 agent
-        needsCreateAgent = true;
-      } else if (isSubmit) {
-        // 有 marketIdentifier 且是 submit 操作，需要检查是否是自己的 agent
-        const userInfo = getCurrentUserInfo?.() ?? session?.userInfo;
-        const accountId = userInfo?.accountId;
-
-        if (accountId) {
-          const isOwner = await checkOwnership({
-            accessToken: session?.accessToken,
-            accountId,
-            enableMarketTrustedClient,
-            marketIdentifier: identifier,
-          });
-
-          if (!isOwner) {
-            // 不是自己的 agent，需要创建新的
-            needsCreateAgent = true;
-          }
-        } else {
-          // 无法获取用户 ID，为安全起见创建新 agent
-          needsCreateAgent = true;
-        }
-      }
 
-      if (needsCreateAgent) {
-        identifier = generateMarketIdentifier();
-
-        try {
-          await marketApiService.getAgentDetail(identifier);
-        } catch {
-          const createPayload: Record<string, unknown> = {
-            identifier,
-            name: meta?.title || '',
-          };
-          await marketApiService.createAgent(createPayload as any);
-        }
-      } else if (!identifier) {
-        message.error({
-          content: t('marketPublish.modal.messages.missingIdentifier'),
-          key: messageKey,
-        });
-        return { success: false };
-      }
-
-      const versionPayload = {
+      // 使用 tRPC publishOrCreate - 后端会自动处理 ownership 检查
+      const result = await lambdaClient.market.agent.publishOrCreate.mutate({
         avatar: meta?.avatar,
         changelog,
         config: {
@@ -157,31 +150,16 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
         },
         description: meta?.description || '',
         editorData: editorData,
-        identifier: identifier,
+        // 传递现有的 identifier，后端会检查 ownership
+        identifier: meta?.marketIdentifier,
         name: meta?.title || '',
         tags: meta?.tags,
         tokenUsage: tokenUsage,
-      };
-
-      try {
-        await marketApiService.createAgentVersion(versionPayload);
-      } catch (versionError) {
-        const errorMessage =
-          versionError instanceof Error
-            ? versionError.message
-            : t('unknownError', { ns: 'common' });
-        message.error({
-          content: t('marketPublish.modal.messages.createVersionFailed', {
-            message: errorMessage,
-          }),
-          key: messageKey,
-        });
-        return { success: false };
-      }
+      });
 
-      // 只有在首次创建 agent 时才需要更新 meta
-      if (needsCreateAgent) {
-        updateAgentMeta({ marketIdentifier: identifier });
+      // 如果是新创建的 agent，需要更新 meta
+      if (result.isNewAgent) {
+        updateAgentMeta({ marketIdentifier: result.identifier });
       }
 
       message.success({
@@ -189,8 +167,8 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
         key: messageKey,
       });
 
-      onSuccess?.(identifier!);
-      return { identifier, success: true };
+      onSuccess?.(result.identifier);
+      return { identifier: result.identifier, success: true };
     } catch (error) {
       const errorMessage =
         error instanceof Error ? error.message : t('unknownError', { ns: 'common' });
@@ -211,8 +189,6 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
     chatConfig?.historyCount,
     chatConfig?.searchMode,
     editorData,
-    enableMarketTrustedClient,
-    getCurrentUserInfo,
     isAuthenticated,
     isSubmit,
     language,
@@ -225,8 +201,6 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
     onSuccess,
     plugins,
     provider,
-    session?.accessToken,
-    session?.userInfo,
     systemRole,
     tokenUsage,
     t,
@@ -234,6 +208,8 @@ export const useMarketPublish = ({ action, onSuccess }: UseMarketPublishOptions)
   ]);
 
   return {
+    checkOwnership,
+    isCheckingOwnership,
     isPublishing,
     publish,
   };

package/src/business/client/hooks/useRenderBusinessChatErrorMessageExtra.tsx

@@ -0,0 +1,10 @@
+import { type ChatMessageError } from '@lobechat/types';
+
+export default function useRenderBusinessChatErrorMessageExtra(
+  // eslint-disable-next-line unused-imports/no-unused-vars, @typescript-eslint/no-unused-vars
+  error: ChatMessageError | null | undefined,
+  // eslint-disable-next-line unused-imports/no-unused-vars, @typescript-eslint/no-unused-vars
+  messageId: string,
+) {
+  return null;
+}

package/src/features/CommandMenu/ContextCommands.tsx

@@ -6,11 +6,12 @@ import { useTranslation } from 'react-i18next';
 import { useCommandMenuContext } from './CommandMenuContext';
 import { CommandItem } from './components';
 import { useCommandMenu } from './useCommandMenu';
-import { getContextCommands } from './utils/contextCommands';
+import { CONTEXT_COMMANDS, getContextCommands } from './utils/contextCommands';
 
 const ContextCommands = memo(() => {
   const { t } = useTranslation('setting');
   const { t: tAuth } = useTranslation('auth');
+  const { t: tSubscription } = useTranslation('subscription');
   const { t: tCommon } = useTranslation('common');
   const { handleNavigate } = useCommandMenu();
   const { menuContext, pathname } = useCommandMenuContext();
@@ -23,48 +24,107 @@ const ContextCommands = memo(() => {
 
   const commands = getContextCommands(menuContext, subPath);
 
-  if (commands.length === 0) return null;
+  // Get settings commands to show globally (when not in settings context)
+  const globalSettingsCommands = useMemo(() => {
+    if (menuContext === 'settings') return [];
+    return CONTEXT_COMMANDS.settings;
+  }, [menuContext]);
+
+  const hasCommands = commands.length > 0 || globalSettingsCommands.length > 0;
+
+  if (!hasCommands) return null;
 
   // Get localized context name
   const contextName = tCommon(`cmdk.context.${menuContext}`, { defaultValue: menuContext });
+  const settingsContextName = tCommon('cmdk.context.settings', { defaultValue: 'settings' });
 
   return (
-    <Command.Group>
-      {commands.map((cmd) => {
-        const Icon = cmd.icon;
-        // Get localized label using the correct namespace
-        let label = cmd.label;
-        if (cmd.labelKey) {
-          if (cmd.labelNamespace === 'auth') {
-            label = tAuth(cmd.labelKey, { defaultValue: cmd.label });
-          } else {
-            label = t(cmd.labelKey, { defaultValue: cmd.label });
-          }
-        }
-        const searchValue = `${contextName} ${label} ${cmd.keywords.join(' ')}`;
+    <>
+      {/* Current context commands */}
+      {commands.length > 0 && (
+        <Command.Group>
+          {commands.map((cmd) => {
+            const Icon = cmd.icon;
+            // Get localized label using the correct namespace
+            let label = cmd.label;
+            if (cmd.labelKey) {
+              if (cmd.labelNamespace === 'auth') {
+                label = tAuth(cmd.labelKey, { defaultValue: cmd.label });
+              } else if (cmd.labelNamespace === 'subscription') {
+                label = tSubscription(cmd.labelKey, { defaultValue: cmd.label });
+              } else {
+                label = t(cmd.labelKey, { defaultValue: cmd.label });
+              }
+            }
+            const searchValue = `${contextName} ${label} ${cmd.keywords.join(' ')}`;
+
+            return (
+              <CommandItem
+                icon={<Icon />}
+                key={cmd.path}
+                onSelect={() => handleNavigate(cmd.path)}
+                value={searchValue}
+              >
+                <span style={{ opacity: 0.5 }}>{contextName}</span>
+                <ChevronRight
+                  size={14}
+                  style={{
+                    display: 'inline',
+                    marginInline: '6px',
+                    opacity: 0.5,
+                    verticalAlign: 'middle',
+                  }}
+                />
+                {label}
+              </CommandItem>
+            );
+          })}
+        </Command.Group>
+      )}
+
+      {/* Global settings commands (searchable from any page) */}
+      {globalSettingsCommands.length > 0 && (
+        <Command.Group>
+          {globalSettingsCommands.map((cmd) => {
+            const Icon = cmd.icon;
+            // Get localized label using the correct namespace
+            let label = cmd.label;
+            if (cmd.labelKey) {
+              if (cmd.labelNamespace === 'auth') {
+                label = tAuth(cmd.labelKey, { defaultValue: cmd.label });
+              } else if (cmd.labelNamespace === 'subscription') {
+                label = tSubscription(cmd.labelKey, { defaultValue: cmd.label });
+              } else {
+                label = t(cmd.labelKey, { defaultValue: cmd.label });
+              }
+            }
+            const searchValue = `${settingsContextName} ${label} ${cmd.keywords.join(' ')}`;
 
-        return (
-          <CommandItem
-            icon={<Icon />}
-            key={cmd.path}
-            onSelect={() => handleNavigate(cmd.path)}
-            value={searchValue}
-          >
-            <span style={{ opacity: 0.5 }}>{contextName}</span>
-            <ChevronRight
-              size={14}
-              style={{
-                display: 'inline',
-                marginInline: '6px',
-                opacity: 0.5,
-                verticalAlign: 'middle',
-              }}
-            />
-            {label}
-          </CommandItem>
-        );
-      })}
-    </Command.Group>
+            return (
+              <CommandItem
+                icon={<Icon />}
+                key={cmd.path}
+                onSelect={() => handleNavigate(cmd.path)}
+                unpinned={true}
+                value={searchValue}
+              >
+                <span style={{ opacity: 0.5 }}>{settingsContextName}</span>
+                <ChevronRight
+                  size={14}
+                  style={{
+                    display: 'inline',
+                    marginInline: '6px',
+                    opacity: 0.5,
+                    verticalAlign: 'middle',
+                  }}
+                />
+                {label}
+              </CommandItem>
+            );
+          })}
+        </Command.Group>
+      )}
+    </>
   );
 });