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

package/src/layout/AuthProvider/MarketAuth/ProfileSetupModal.tsx

@@ -9,7 +9,7 @@ import { memo, useCallback, useEffect, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import EmojiPicker from '@/components/EmojiPicker';
-import { MARKET_ENDPOINTS } from '@/services/_url';
+import { lambdaClient } from '@/libs/trpc/client';
 import { useFileStore } from '@/store/file';
 import { useGlobalStore } from '@/store/global';
 import { globalGeneralSelectors } from '@/store/global/selectors';
@@ -211,37 +211,42 @@ const ProfileSetupModal = memo<ProfileSetupModalProps>(
         if (bannerUrl) meta.bannerUrl = bannerUrl;
         if (Object.keys(socialLinks).length > 0) meta.socialLinks = socialLinks;
 
-        const response = await fetch(MARKET_ENDPOINTS.updateUserProfile, {
-          body: JSON.stringify({
-            avatarUrl: avatarUrl || undefined,
-            displayName: values.displayName,
-            meta: Object.keys(meta).length > 0 ? meta : undefined,
-            userName: values.userName,
-          }),
-          headers: {
-            'Authorization': `Bearer ${accessToken}`,
-            'Content-Type': 'application/json',
-          },
-          method: 'PUT',
+        const result = await lambdaClient.market.user.updateUserProfile.mutate({
+          avatarUrl: avatarUrl || undefined,
+          displayName: values.displayName,
+          meta: Object.keys(meta).length > 0 ? meta : undefined,
+          userName: values.userName,
         });
 
-        if (!response.ok) {
-          const errorData = await response.json();
-          if (errorData.error === 'username_taken') {
-            message.error(t('profileSetup.errors.usernameTaken'));
-            return;
-          }
-          throw new Error(errorData.message || 'Update failed');
-        }
-
-        const data = await response.json();
         message.success(t('profileSetup.success'));
-        onSuccess?.(data.user);
+        // Cast result.user to MarketUserProfile with required fields
+        const userProfile: MarketUserProfile = {
+          avatarUrl: result.user?.avatarUrl || avatarUrl || null,
+          bannerUrl: bannerUrl || null,
+          createdAt: result.user?.createdAt || new Date().toISOString(),
+          description: values.description || null,
+          displayName: values.displayName || null,
+          id: result.user?.id || 0,
+          namespace: result.user?.namespace || '',
+          socialLinks: Object.keys(socialLinks).length > 0 ? socialLinks : null,
+          type: result.user?.type || null,
+          userName: values.userName || null,
+        };
+        onSuccess?.(userProfile);
         onClose();
       } catch (error) {
         console.error('[ProfileSetupModal] Update failed:', error);
         if (error instanceof Error && error.message !== 'Validation failed') {
-          message.error(t('profileSetup.errors.updateFailed'));
+          // Check for username taken error (tRPC CONFLICT code)
+          const errorMessage = error.message || '';
+          if (
+            errorMessage.toLowerCase().includes('already taken') ||
+            errorMessage.includes('CONFLICT')
+          ) {
+            message.error(t('profileSetup.errors.usernameTaken'));
+          } else {
+            message.error(t('profileSetup.errors.updateFailed'));
+          }
         }
       } finally {
         setLoading(false);

package/src/layout/AuthProvider/MarketAuth/useMarketUserProfile.ts

@@ -1,20 +1,15 @@
 import useSWR from 'swr';
 
-import { MARKET_ENDPOINTS } from '@/services/_url';
+import { lambdaClient } from '@/libs/trpc/client';
 
 import { type MarketUserProfile } from './types';
 
 /**
- * Fetcher function for user profile
+ * Fetcher function for user profile using tRPC
  */
 const fetchUserProfile = async (username: string): Promise<MarketUserProfile | null> => {
-  const response = await fetch(MARKET_ENDPOINTS.getUserProfile(username));
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch user profile: ${response.status}`);
-  }
-
-  return response.json();
+  const result = await lambdaClient.market.user.getUserByUsername.query({ username });
+  return result as MarketUserProfile;
 };
 
 /**

package/src/libs/redis/manager.ts

@@ -2,6 +2,33 @@ import { IoRedisRedisProvider } from './redis';
 import { type BaseRedisProvider, type RedisConfig } from './types';
 import { UpstashRedisProvider } from './upstash';
 
+/**
+ * Create a Redis provider instance based on config
+ *
+ * @param config - Redis config
+ * @param prefix - Optional custom prefix to override config.prefix
+ * @returns Provider instance or null if disabled/unsupported
+ */
+const createProvider = (config: RedisConfig, prefix?: string): BaseRedisProvider | null => {
+  if (!config.enabled) return null;
+
+  const actualPrefix = prefix ?? config.prefix;
+
+  if (config.provider === 'redis') {
+    return new IoRedisRedisProvider({ ...config, prefix: actualPrefix });
+  }
+
+  if (config.provider === 'upstash') {
+    return new UpstashRedisProvider({
+      prefix: actualPrefix,
+      token: config.token,
+      url: config.url,
+    });
+  }
+
+  return null;
+};
+
 class RedisManager {
   private static instance: BaseRedisProvider | null = null;
   // NOTICE: initPromise keeps concurrent initialize() calls sharing the same in-flight setup,
@@ -13,25 +40,13 @@ class RedisManager {
     if (RedisManager.initPromise) return RedisManager.initPromise;
 
     RedisManager.initPromise = (async () => {
-      if (!config.enabled) {
+      const provider = createProvider(config);
+
+      if (!provider) {
         RedisManager.instance = null;
         return null;
       }
 
-      let provider: BaseRedisProvider;
-
-      if (config.provider === 'redis') {
-        provider = new IoRedisRedisProvider(config);
-      } else if (config.provider === 'upstash') {
-        provider = new UpstashRedisProvider({
-          prefix: config.prefix,
-          token: config.token,
-          url: config.url,
-        });
-      } else {
-        throw new Error(`Unsupported redis provider: ${String((config as any).provider)}`);
-      }
-
       await provider.initialize();
       RedisManager.instance = provider;
 
@@ -58,3 +73,24 @@ export const initializeRedis = (config: RedisConfig) => RedisManager.initialize(
 export const resetRedisClient = () => RedisManager.reset();
 export const isRedisEnabled = (config: RedisConfig) => config.enabled;
 export { RedisManager };
+
+/**
+ * Create a Redis client with custom prefix
+ *
+ * Unlike initializeRedis, this creates an independent client
+ * that doesn't share the singleton instance.
+ *
+ * @param config - Redis config
+ * @param prefix - Custom prefix for all keys (e.g., 'aiGeneration')
+ * @returns Redis client or null if Redis is disabled
+ */
+export const createRedisWithPrefix = async (
+  config: RedisConfig,
+  prefix: string,
+): Promise<BaseRedisProvider | null> => {
+  const provider = createProvider(config, prefix);
+  if (!provider) return null;
+
+  await provider.initialize();
+  return provider;
+};

package/src/libs/trpc/lambda/middleware/index.ts

@@ -1,4 +1,5 @@
 export * from './keyVaults';
+export * from './marketSDK';
 export * from './marketUserInfo';
 export * from './serverDatabase';
 export * from './telemetry';

package/src/libs/trpc/lambda/middleware/marketSDK.ts

@@ -0,0 +1,68 @@
+import { MarketSDK } from '@lobehub/market-sdk';
+
+import { generateTrustedClientToken, type TrustedClientUserInfo } from '@/libs/trusted-client';
+
+import { trpc } from '../init';
+
+interface ContextWithMarketUserInfo {
+  marketAccessToken?: string;
+  marketUserInfo?: TrustedClientUserInfo;
+}
+
+/**
+ * Middleware that initializes MarketSDK with proper authentication.
+ * This requires marketUserInfo middleware to be applied first.
+ *
+ * Provides:
+ * - ctx.marketSDK: Initialized MarketSDK instance with trustedClientToken and optional accessToken
+ * - ctx.trustedClientToken: The generated trusted client token (if available)
+ */
+export const marketSDK = trpc.middleware(async (opts) => {
+  const ctx = opts.ctx as ContextWithMarketUserInfo;
+
+  // Generate trusted client token if user info is available
+  const trustedClientToken = ctx.marketUserInfo
+    ? generateTrustedClientToken(ctx.marketUserInfo)
+    : undefined;
+
+  // Initialize MarketSDK with both authentication methods
+  const market = new MarketSDK({
+    accessToken: ctx.marketAccessToken,
+    baseURL: process.env.NEXT_PUBLIC_MARKET_BASE_URL,
+    trustedClientToken,
+  });
+
+  return opts.next({
+    ctx: {
+      marketSDK: market,
+      trustedClientToken,
+    },
+  });
+});
+
+/**
+ * Middleware that requires authentication for Market API access.
+ * This middleware ensures that either accessToken or trustedClientToken is available.
+ * It should be used after marketUserInfo and marketSDK middlewares.
+ *
+ * Throws UNAUTHORIZED error if neither authentication method is available.
+ */
+export const requireMarketAuth = trpc.middleware(async (opts) => {
+  const ctx = opts.ctx as ContextWithMarketUserInfo & {
+    trustedClientToken?: string;
+  };
+
+  // Check if any authentication is available
+  const hasAccessToken = !!ctx.marketAccessToken;
+  const hasTrustedToken = !!ctx.trustedClientToken;
+
+  if (!hasAccessToken && !hasTrustedToken) {
+    const { TRPCError } = await import('@trpc/server');
+    throw new TRPCError({
+      code: 'UNAUTHORIZED',
+      message: 'Authentication required. Please sign in.',
+    });
+  }
+
+  return opts.next();
+});

package/src/locales/default/common.ts

@@ -133,8 +133,8 @@ export default {
   'cmdk.navigate': 'Navigate',
   'cmdk.newAgent': 'Create New Agent',
   'cmdk.newAgentTeam': 'Create New Group',
-  'cmdk.newLibrary': 'New Library',
-  'cmdk.newPage': 'New Page',
+  'cmdk.newLibrary': 'Create New Library',
+  'cmdk.newPage': 'Create New Page',
   'cmdk.newTopic': 'New topic in current Agent',
   'cmdk.noResults': 'No results found',
   'cmdk.openSettings': 'Open Settings',

package/src/locales/default/setting.ts

@@ -140,6 +140,11 @@ export default {
   'llm.proxyUrl.title': 'API proxy URL',
   'llm.waitingForMore': 'More models are <1>planned to be added</1>, stay tuned',
   'llm.waitingForMoreLinkAriaLabel': 'Open the Provider request form',
+  'marketPublish.forkConfirm.by': 'by {{author}}',
+  'marketPublish.forkConfirm.confirm': 'Confirm Publish',
+  'marketPublish.forkConfirm.description':
+    'You are about to publish a derivative version based on an existing agent from the community. Your new agent will be created as a separate entry in the marketplace.',
+  'marketPublish.forkConfirm.title': 'Publish Derivative Agent',
   'marketPublish.modal.changelog.extra':
     'Describe the key changes and improvements in this version',
   'marketPublish.modal.changelog.label': 'Changelog',