@lobehub/lobehub 2.0.0-next.225 → 2.0.0-next.227

package/src/server/routers/lambda/market/oidc.ts

@@ -0,0 +1,169 @@
+import { MarketSDK } from '@lobehub/market-sdk';
+import { TRPCError } from '@trpc/server';
+import debug from 'debug';
+import { z } from 'zod';
+
+import { publicProcedure, router } from '@/libs/trpc/lambda';
+import { marketUserInfo, serverDatabase } from '@/libs/trpc/lambda/middleware';
+import { generateTrustedClientToken } from '@/libs/trusted-client';
+
+const log = debug('lambda-router:market:oidc');
+
+const MARKET_BASE_URL = process.env.NEXT_PUBLIC_MARKET_BASE_URL || 'https://market.lobehub.com';
+
+// OIDC procedures are public (used during authentication flow)
+const oidcProcedure = publicProcedure.use(serverDatabase).use(marketUserInfo);
+
+export const oidcRouter = router({
+  /**
+   * Exchange OAuth code for tokens
+   * POST /market/oidc/token (with grant_type=authorization_code)
+   */
+  exchangeAuthorizationCode: oidcProcedure
+    .input(
+      z.object({
+        clientId: z.string(),
+        code: z.string(),
+        codeVerifier: z.string(),
+        redirectUri: z.string(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      log('exchangeAuthorizationCode input: %O', { ...input, code: '[REDACTED]' });
+
+      const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
+
+      try {
+        const response = await market.auth.exchangeOAuthToken({
+          clientId: input.clientId,
+          code: input.code,
+          codeVerifier: input.codeVerifier,
+          grantType: 'authorization_code',
+          redirectUri: input.redirectUri,
+        });
+        return response;
+      } catch (error) {
+        log('Error exchanging authorization code: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to exchange authorization code',
+        });
+      }
+    }),
+
+  /**
+   * Get OAuth handoff information
+   * GET /market/oidc/handoff?id=xxx
+   */
+  getOAuthHandoff: oidcProcedure.input(z.object({ id: z.string() })).query(async ({ input }) => {
+    log('getOAuthHandoff input: %O', input);
+
+    const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
+
+    try {
+      const handoff = await market.auth.getOAuthHandoff(input.id);
+      return handoff;
+    } catch (error) {
+      log('Error getting OAuth handoff: %O', error);
+      throw new TRPCError({
+        cause: error,
+        code: 'INTERNAL_SERVER_ERROR',
+        message: error instanceof Error ? error.message : 'Failed to get OAuth handoff',
+      });
+    }
+  }),
+
+  /**
+   * Get user info from token or trusted client
+   * POST /market/oidc/userinfo
+   */
+  getUserInfo: oidcProcedure
+    .input(z.object({ token: z.string().optional() }))
+    .mutation(async ({ input, ctx }) => {
+      log('getUserInfo input: token=%s', input.token ? '[REDACTED]' : 'undefined');
+
+      const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
+
+      try {
+        // If token is provided, use it
+        if (input.token) {
+          const response = await market.auth.getUserInfo(input.token);
+          return response;
+        }
+
+        // Otherwise, try to use trustedClientToken
+        if (ctx.marketUserInfo) {
+          const trustedClientToken = generateTrustedClientToken(ctx.marketUserInfo);
+
+          if (trustedClientToken) {
+            const userInfoUrl = `${MARKET_BASE_URL}/lobehub-oidc/userinfo`;
+            const response = await fetch(userInfoUrl, {
+              headers: {
+                'Content-Type': 'application/json',
+                'x-lobe-trust-token': trustedClientToken,
+              },
+              method: 'GET',
+            });
+
+            if (!response.ok) {
+              throw new Error(
+                `Failed to fetch user info: ${response.status} ${response.statusText}`,
+              );
+            }
+
+            return await response.json();
+          }
+        }
+
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'Token is required for userinfo',
+        });
+      } catch (error) {
+        if (error instanceof TRPCError) throw error;
+
+        log('Error getting user info: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get user info',
+        });
+      }
+    }),
+
+  /**
+   * Refresh access token
+   * POST /market/oidc/token (with grant_type=refresh_token)
+   */
+  refreshToken: oidcProcedure
+    .input(
+      z.object({
+        clientId: z.string().optional(),
+        refreshToken: z.string(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      log('refreshToken input: %O', { ...input, refreshToken: '[REDACTED]' });
+
+      const market = new MarketSDK({ baseURL: MARKET_BASE_URL });
+
+      try {
+        const response = await market.auth.exchangeOAuthToken({
+          clientId: input.clientId,
+          grantType: 'refresh_token',
+          refreshToken: input.refreshToken,
+        });
+        return response;
+      } catch (error) {
+        log('Error refreshing token: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to refresh token',
+        });
+      }
+    }),
+});
+
+export type OidcRouter = typeof oidcRouter;

package/src/server/routers/lambda/market/social.ts

@@ -0,0 +1,532 @@
+import { TRPCError } from '@trpc/server';
+import debug from 'debug';
+import { z } from 'zod';
+
+import { authedProcedure, publicProcedure, router } from '@/libs/trpc/lambda';
+import { marketSDK, marketUserInfo, serverDatabase } from '@/libs/trpc/lambda/middleware';
+
+const log = debug('lambda-router:market:social');
+
+// Authenticated procedure for social actions that require login
+const socialAuthProcedure = authedProcedure.use(serverDatabase).use(marketUserInfo).use(marketSDK);
+
+// Public procedure with optional auth for status checks
+const socialPublicProcedure = publicProcedure
+  .use(serverDatabase)
+  .use(marketUserInfo)
+  .use(marketSDK);
+
+// Schema definitions
+const targetTypeSchema = z.enum(['agent', 'plugin']);
+
+const paginationSchema = z.object({
+  limit: z.number().optional(),
+  offset: z.number().optional(),
+});
+
+export const socialRouter = router({
+  // ============================== Favorite Actions ==============================
+  /**
+   * Add to favorites
+   * POST /market/social/favorite
+   */
+  addFavorite: socialAuthProcedure
+    .input(
+      z.object({
+        identifier: z.string().optional(),
+        targetId: z.number().optional(),
+        targetType: targetTypeSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('addFavorite input: %O', input);
+
+      try {
+        const targetValue = input.identifier ?? input.targetId;
+        if (!targetValue) {
+          throw new Error('Either identifier or targetId is required');
+        }
+        await ctx.marketSDK.favorites.addFavorite(input.targetType, targetValue as any);
+        return { success: true };
+      } catch (error) {
+        log('Error adding favorite: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to add favorite',
+        });
+      }
+    }),
+
+  /**
+   * Check if item is favorited
+   * GET /market/social/favorite-status/[targetType]/[targetId]
+   */
+  checkFavorite: socialPublicProcedure
+    .input(
+      z.object({
+        targetIdOrIdentifier: z.union([z.number(), z.string()]),
+        targetType: targetTypeSchema,
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      log('checkFavorite input: %O', input);
+
+      if (!ctx.marketSDK) {
+        return { isFavorited: false };
+      }
+
+      try {
+        const result = await ctx.marketSDK.favorites.checkFavorite(
+          input.targetType,
+          input.targetIdOrIdentifier as any,
+        );
+        return result;
+      } catch (error) {
+        log('Error checking favorite: %O', error);
+        return { isFavorited: false };
+      }
+    }),
+
+  // ============================== Follow Actions ==============================
+  /**
+   * Check follow status between current user and target user
+   * GET /market/social/follow-status/[userId]
+   */
+  checkFollowStatus: socialPublicProcedure
+    .input(z.object({ targetUserId: z.number() }))
+    .query(async ({ input, ctx }) => {
+      log('checkFollowStatus input: %O', input);
+
+      // If no auth, return default status
+      if (!ctx.marketSDK) {
+        return { isFollowing: false, isMutual: false };
+      }
+
+      try {
+        const result = await ctx.marketSDK.follows.checkFollowStatus(input.targetUserId);
+        return result;
+      } catch (error) {
+        log('Error checking follow status: %O', error);
+        // Return default on error (user might not be authenticated)
+        return { isFollowing: false, isMutual: false };
+      }
+    }),
+
+  // ============================== Like Actions ==============================
+  /**
+   * Check if item is liked
+   * GET /market/social/like-status/[targetType]/[targetId]
+   */
+  checkLike: socialPublicProcedure
+    .input(
+      z.object({
+        targetIdOrIdentifier: z.union([z.number(), z.string()]),
+        targetType: targetTypeSchema,
+      }),
+    )
+    .query(async ({ input, ctx }) => {
+      log('checkLike input: %O', input);
+
+      if (!ctx.marketSDK) {
+        return { isLiked: false };
+      }
+
+      try {
+        const result = await ctx.marketSDK.likes.checkLike(
+          input.targetType,
+          input.targetIdOrIdentifier as any,
+        );
+        return result;
+      } catch (error) {
+        log('Error checking like: %O', error);
+        return { isLiked: false };
+      }
+    }),
+
+  /**
+   * Follow a user
+   * POST /market/social/follow
+   */
+  follow: socialAuthProcedure
+    .input(z.object({ followingId: z.number() }))
+    .mutation(async ({ input, ctx }) => {
+      log('follow input: %O', input);
+
+      try {
+        await ctx.marketSDK.follows.follow(input.followingId);
+        return { success: true };
+      } catch (error) {
+        log('Error following user: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to follow user',
+        });
+      }
+    }),
+
+  /**
+   * Get follow counts for a user
+   * GET /market/social/follow-counts/[userId]
+   */
+  getFollowCounts: socialPublicProcedure
+    .input(z.object({ userId: z.number() }))
+    .query(async ({ input, ctx }) => {
+      log('getFollowCounts input: %O', input);
+
+      try {
+        const [following, followers] = await Promise.all([
+          ctx.marketSDK.follows.getFollowing(input.userId, { limit: 1 }),
+          ctx.marketSDK.follows.getFollowers(input.userId, { limit: 1 }),
+        ]);
+
+        return {
+          followersCount: (followers as any).totalCount || (followers as any).total || 0,
+          followingCount: (following as any).totalCount || (following as any).total || 0,
+        };
+      } catch (error) {
+        log('Error getting follow counts: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get follow counts',
+        });
+      }
+    }),
+
+  /**
+   * Get followers of a user
+   * GET /market/social/followers/[userId]
+   */
+  getFollowers: socialPublicProcedure
+    .input(z.object({ userId: z.number() }).merge(paginationSchema))
+    .query(async ({ input, ctx }) => {
+      log('getFollowers input: %O', input);
+
+      try {
+        const { userId, ...params } = input;
+        const result = await ctx.marketSDK.follows.getFollowers(userId, params);
+        return result;
+      } catch (error) {
+        log('Error getting followers: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get followers',
+        });
+      }
+    }),
+
+  /**
+   * Get users that a user is following
+   * GET /market/social/following/[userId]
+   */
+  getFollowing: socialPublicProcedure
+    .input(z.object({ userId: z.number() }).merge(paginationSchema))
+    .query(async ({ input, ctx }) => {
+      log('getFollowing input: %O', input);
+
+      try {
+        const { userId, ...params } = input;
+        const result = await ctx.marketSDK.follows.getFollowing(userId, params);
+        return result;
+      } catch (error) {
+        log('Error getting following: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get following',
+        });
+      }
+    }),
+
+  /**
+   * Get current user's favorites
+   * GET /market/social/favorites
+   */
+  getMyFavorites: socialAuthProcedure
+    .input(paginationSchema.optional())
+    .query(async ({ input, ctx }) => {
+      log('getMyFavorites input: %O', input);
+
+      try {
+        const result = await ctx.marketSDK.favorites.getMyFavorites(input);
+        return result;
+      } catch (error) {
+        log('Error getting my favorites: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get favorites',
+        });
+      }
+    }),
+
+  /**
+   * Get user's favorite agents
+   * GET /market/social/favorite-agents/[userId]
+   */
+  getUserFavoriteAgents: socialPublicProcedure
+    .input(z.object({ userId: z.number() }).merge(paginationSchema))
+    .query(async ({ input, ctx }) => {
+      log('getUserFavoriteAgents input: %O', input);
+
+      try {
+        const { userId, ...params } = input;
+        const result = await ctx.marketSDK.favorites.getUserFavoriteAgents(userId, params);
+        return result;
+      } catch (error) {
+        log('Error getting user favorite agents: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get favorite agents',
+        });
+      }
+    }),
+
+  /**
+   * Get user's favorite plugins
+   * GET /market/social/favorite-plugins/[userId]
+   */
+  getUserFavoritePlugins: socialPublicProcedure
+    .input(z.object({ userId: z.number() }).merge(paginationSchema))
+    .query(async ({ input, ctx }) => {
+      log('getUserFavoritePlugins input: %O', input);
+
+      try {
+        const { userId, ...params } = input;
+        const result = await ctx.marketSDK.favorites.getUserFavoritePlugins(userId, params);
+        return result;
+      } catch (error) {
+        log('Error getting user favorite plugins: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get favorite plugins',
+        });
+      }
+    }),
+
+  /**
+   * Get user's all favorites
+   * GET /market/social/user-favorites/[userId]
+   */
+  getUserFavorites: socialPublicProcedure
+    .input(z.object({ userId: z.number() }).merge(paginationSchema))
+    .query(async ({ input, ctx }) => {
+      log('getUserFavorites input: %O', input);
+
+      try {
+        const { userId, ...params } = input;
+        const result = await ctx.marketSDK.favorites.getUserFavorites(userId, params);
+        return result;
+      } catch (error) {
+        log('Error getting user favorites: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get user favorites',
+        });
+      }
+    }),
+
+  /**
+   * Get user's liked agents
+   * GET /market/social/liked-agents/[userId]
+   */
+  getUserLikedAgents: socialPublicProcedure
+    .input(z.object({ userId: z.number() }).merge(paginationSchema))
+    .query(async ({ input, ctx }) => {
+      log('getUserLikedAgents input: %O', input);
+
+      try {
+        const { userId, ...params } = input;
+        const result = await ctx.marketSDK.likes.getUserLikedAgents(userId, params);
+        return result;
+      } catch (error) {
+        log('Error getting user liked agents: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get liked agents',
+        });
+      }
+    }),
+
+  /**
+   * Get user's liked plugins
+   * GET /market/social/liked-plugins/[userId]
+   */
+  getUserLikedPlugins: socialPublicProcedure
+    .input(z.object({ userId: z.number() }).merge(paginationSchema))
+    .query(async ({ input, ctx }) => {
+      log('getUserLikedPlugins input: %O', input);
+
+      try {
+        const { userId, ...params } = input;
+        const result = await ctx.marketSDK.likes.getUserLikedPlugins(userId, params);
+        return result;
+      } catch (error) {
+        log('Error getting user liked plugins: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to get liked plugins',
+        });
+      }
+    }),
+
+  /**
+   * Like an item
+   * POST /market/social/like
+   */
+  like: socialAuthProcedure
+    .input(
+      z.object({
+        identifier: z.string().optional(),
+        targetId: z.number().optional(),
+        targetType: targetTypeSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('like input: %O', input);
+
+      try {
+        const targetValue = input.identifier ?? input.targetId;
+        if (!targetValue) {
+          throw new Error('Either identifier or targetId is required');
+        }
+        await ctx.marketSDK.likes.like(input.targetType, targetValue as any);
+        return { success: true };
+      } catch (error) {
+        log('Error liking item: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to like item',
+        });
+      }
+    }),
+
+  /**
+   * Remove from favorites
+   * POST /market/social/unfavorite
+   */
+  removeFavorite: socialAuthProcedure
+    .input(
+      z.object({
+        identifier: z.string().optional(),
+        targetId: z.number().optional(),
+        targetType: targetTypeSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('removeFavorite input: %O', input);
+
+      try {
+        const targetValue = input.identifier ?? input.targetId;
+        if (!targetValue) {
+          throw new Error('Either identifier or targetId is required');
+        }
+        await ctx.marketSDK.favorites.removeFavorite(input.targetType, targetValue as any);
+        return { success: true };
+      } catch (error) {
+        log('Error removing favorite: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to remove favorite',
+        });
+      }
+    }),
+
+  /**
+   * Toggle like on an item
+   * POST /market/social/toggle-like
+   */
+  toggleLike: socialAuthProcedure
+    .input(
+      z.object({
+        identifier: z.string().optional(),
+        targetId: z.number().optional(),
+        targetType: targetTypeSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('toggleLike input: %O', input);
+
+      try {
+        const targetValue = input.identifier ?? input.targetId;
+        if (!targetValue) {
+          throw new Error('Either identifier or targetId is required');
+        }
+        const result = await ctx.marketSDK.likes.toggleLike(input.targetType, targetValue as any);
+        return result;
+      } catch (error) {
+        log('Error toggling like: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to toggle like',
+        });
+      }
+    }),
+
+  /**
+   * Unfollow a user
+   * POST /market/social/unfollow
+   */
+  unfollow: socialAuthProcedure
+    .input(z.object({ followingId: z.number() }))
+    .mutation(async ({ input, ctx }) => {
+      log('unfollow input: %O', input);
+
+      try {
+        await ctx.marketSDK.follows.unfollow(input.followingId);
+        return { success: true };
+      } catch (error) {
+        log('Error unfollowing user: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to unfollow user',
+        });
+      }
+    }),
+
+  /**
+   * Unlike an item
+   * POST /market/social/unlike
+   */
+  unlike: socialAuthProcedure
+    .input(
+      z.object({
+        identifier: z.string().optional(),
+        targetId: z.number().optional(),
+        targetType: targetTypeSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      log('unlike input: %O', input);
+
+      try {
+        const targetValue = input.identifier ?? input.targetId;
+        if (!targetValue) {
+          throw new Error('Either identifier or targetId is required');
+        }
+        await ctx.marketSDK.likes.unlike(input.targetType, targetValue as any);
+        return { success: true };
+      } catch (error) {
+        log('Error unliking item: %O', error);
+        throw new TRPCError({
+          cause: error,
+          code: 'INTERNAL_SERVER_ERROR',
+          message: error instanceof Error ? error.message : 'Failed to unlike item',
+        });
+      }
+    }),
+});
+
+export type SocialRouter = typeof socialRouter;