@lobehub/lobehub 2.0.0-next.46 → 2.0.0-next.48

package/src/app/(backend)/market/agent/[[...segments]]/route.ts

@@ -0,0 +1,153 @@
+import { MarketSDK } from '@lobehub/market-sdk';
+import { NextRequest, NextResponse } from 'next/server';
+
+type RouteContext = {
+  params: Promise<{
+    segments?: string[];
+  }>;
+};
+
+const MARKET_BASE_URL = process.env.NEXT_PUBLIC_MARKET_BASE_URL || 'http://127.0.0.1:8787';
+
+const extractAccessToken = (req: NextRequest) => {
+  const authorization = req.headers.get('authorization');
+  if (!authorization) return undefined;
+
+  const [scheme, token] = authorization.split(' ');
+  if (scheme?.toLowerCase() !== 'bearer' || !token) return undefined;
+
+  return token;
+};
+
+const methodNotAllowed = (methods: string[]) =>
+  NextResponse.json(
+    {
+      error: 'method_not_allowed',
+      message: `Allowed methods: ${methods.join(', ')}`,
+      status: 'error',
+    },
+    {
+      headers: { Allow: methods.join(', ') },
+      status: 405,
+    },
+  );
+
+const badRequest = (error: string, message: string) =>
+  NextResponse.json(
+    {
+      error,
+      message,
+      status: 'error',
+    },
+    { status: 400 },
+  );
+
+const notFound = (reason: string) =>
+  NextResponse.json(
+    {
+      error: 'not_found',
+      message: reason,
+      status: 'error',
+    },
+    { status: 404 },
+  );
+
+const handleAgent = async (req: NextRequest, segments: string[]) => {
+  const accessToken = extractAccessToken(req);
+  const market = new MarketSDK({
+    accessToken,
+    baseURL: MARKET_BASE_URL,
+  });
+
+  if (segments.length === 0) {
+    return notFound('Missing agent action.');
+  }
+
+  const [action, ...rest] = segments;
+
+  if (action === 'create') {
+    if (req.method !== 'POST') return methodNotAllowed(['POST']);
+
+    try {
+      const payload = await req.json();
+      const response = await market.agents.createAgent(payload);
+      return NextResponse.json(response);
+    } catch (error) {
+      console.error('[Market] Failed to create agent:', error);
+      return NextResponse.json(
+        {
+          error: 'create_agent_failed',
+          message: error instanceof Error ? error.message : 'Unknown error',
+          status: 'error',
+        },
+        { status: 500 },
+      );
+    }
+  }
+
+  if (action === 'versions') {
+    if (rest.length !== 1 || rest[0] !== 'create') {
+      return notFound('Requested agent version endpoint is not available.');
+    }
+
+    if (req.method !== 'POST') return methodNotAllowed(['POST']);
+
+    try {
+      const payload = await req.json();
+      if (typeof payload !== 'object' || payload === null) {
+        return badRequest('invalid_payload', 'Request body must be a JSON object.');
+      }
+
+      const identifier = (payload as { identifier?: string }).identifier;
+      if (!identifier) {
+        return badRequest('missing_identifier', 'Identifier is required to create agent version.');
+      }
+
+      const response = await market.agents.createAgentVersion(payload);
+      return NextResponse.json(response);
+    } catch (error) {
+      console.error('[Market] Failed to create agent version:', error);
+      return NextResponse.json(
+        {
+          error: 'create_agent_version_failed',
+          message: error instanceof Error ? error.message : 'Unknown error',
+          status: 'error',
+        },
+        { status: 500 },
+      );
+    }
+  }
+
+  if (segments.length === 1) {
+    if (req.method !== 'GET') return methodNotAllowed(['GET']);
+
+    try {
+      const response = await market.agents.getAgentDetail(action);
+      return NextResponse.json(response);
+    } catch (error) {
+      console.error('[Market] Failed to get agent detail:', error);
+      return NextResponse.json(
+        {
+          error: 'get_agent_detail_failed',
+          message: error instanceof Error ? error.message : 'Unknown error',
+          status: 'error',
+        },
+        { status: 500 },
+      );
+    }
+  }
+
+  return notFound('Requested agent endpoint is not available.');
+};
+
+const handleProxy = async (req: NextRequest, context: RouteContext) => {
+  const { segments } = await context.params;
+  const normalizedSegments = segments?.map((segment) => decodeURIComponent(segment)) ?? [];
+
+  return handleAgent(req, normalizedSegments);
+};
+
+export const GET = (req: NextRequest, context: RouteContext) => handleProxy(req, context);
+export const POST = (req: NextRequest, context: RouteContext) => handleProxy(req, context);
+
+export const dynamic = 'force-dynamic';

package/src/app/(backend)/market/oidc/[[...segments]]/route.ts

@@ -0,0 +1,207 @@
+import { MarketSDK } from '@lobehub/market-sdk';
+import { NextRequest, NextResponse } from 'next/server';
+
+type RouteContext = {
+  params: Promise<{
+    segments?: string[];
+  }>;
+};
+
+const MARKET_BASE_URL = process.env.NEXT_PUBLIC_MARKET_BASE_URL || 'http://127.0.0.1:8787';
+const ALLOWED_ENDPOINTS = new Set(['handoff', 'token', 'userinfo']);
+
+const ensureEndpoint = (segments?: string[]) => {
+  if (!segments || segments.length === 0) {
+    return { error: 'missing_endpoint', status: 404 } as const;
+  }
+
+  if (segments.length !== 1) {
+    return { error: 'unsupported_nested_path', status: 404 } as const;
+  }
+
+  const endpoint = segments[0];
+
+  if (!ALLOWED_ENDPOINTS.has(endpoint)) {
+    return { error: 'unknown_endpoint', status: 404 } as const;
+  }
+
+  return { endpoint } as const;
+};
+
+const methodNotAllowed = (allowed: string[]) =>
+  NextResponse.json(
+    {
+      error: 'method_not_allowed',
+      message: `Allowed methods: ${allowed.join(', ')}`,
+      status: 'error',
+    },
+    {
+      headers: { Allow: allowed.join(', ') },
+      status: 405,
+    },
+  );
+
+const handleProxy = async (req: NextRequest, context: RouteContext) => {
+  const market = new MarketSDK({
+    baseURL: MARKET_BASE_URL,
+  });
+
+  const { segments } = await context.params;
+  const endpointResult = ensureEndpoint(segments);
+
+  if ('error' in endpointResult) {
+    return NextResponse.json(
+      {
+        error: endpointResult.error,
+        message: 'Requested endpoint is not available.',
+        status: 'error',
+      },
+      { status: endpointResult.status },
+    );
+  }
+
+  const endpoint = endpointResult.endpoint;
+
+  switch (endpoint) {
+    case 'handoff': {
+      try {
+        const id = req.nextUrl.searchParams.get('id');
+        if (id) {
+          const handoff = await market.auth.getOAuthHandoff(id);
+          return new NextResponse(JSON.stringify(handoff), { status: 200 });
+        } else {
+          return NextResponse.json(
+            {
+              error: 'missing_id',
+              message: 'ID is required for handoff proxy.',
+              status: 'error',
+            },
+            { status: 400 },
+          );
+        }
+      } catch (error) {
+        return NextResponse.json(
+          {
+            error: 'handoff_proxy_failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+            status: 'error',
+          },
+          { status: 500 },
+        );
+      }
+    }
+
+    case 'token': {
+      if (req.method !== 'POST') {
+        return methodNotAllowed(['POST']);
+      }
+
+      try {
+        const body = await req.text();
+        const form = new URLSearchParams(body);
+
+        const grantType = (form.get('grant_type') || 'authorization_code') as
+          | 'authorization_code'
+          | 'refresh_token';
+
+        if (grantType === 'authorization_code') {
+          const clientId = form.get('client_id');
+          const code = form.get('code');
+          const codeVerifier = form.get('code_verifier');
+          const redirectUri = form.get('redirect_uri');
+
+          const response = await market.auth.exchangeOAuthToken({
+            clientId: clientId as string,
+            code: code as string,
+            codeVerifier: codeVerifier as string,
+            grantType: 'authorization_code',
+            redirectUri: redirectUri as string,
+          });
+
+          return NextResponse.json(response);
+        }
+
+        if (grantType === 'refresh_token') {
+          const refreshToken = form.get('refresh_token');
+          const clientId = form.get('client_id');
+
+          const response = await market.auth.exchangeOAuthToken({
+            clientId: clientId ?? undefined,
+            grantType: 'refresh_token',
+            refreshToken: refreshToken as string,
+          });
+
+          return NextResponse.json(response);
+        }
+
+        return NextResponse.json(
+          {
+            error: 'unsupported_grant_type',
+            message: `Unsupported grant_type: ${grantType}`,
+            status: 'error',
+          },
+          { status: 400 },
+        );
+      } catch (error) {
+        console.error('[MarketOIDC] Failed to proxy token request:', error);
+        return NextResponse.json(
+          {
+            error: 'token_proxy_failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+            status: 'error',
+          },
+          { status: 500 },
+        );
+      }
+    }
+
+    case 'userinfo': {
+      if (req.method !== 'POST') {
+        return methodNotAllowed(['POST']);
+      }
+
+      try {
+        const { token } = (await req.json()) as { token?: string };
+        if (!token) {
+          return NextResponse.json(
+            {
+              error: 'missing_token',
+              message: 'Token is required for userinfo proxy.',
+              status: 'error',
+            },
+            { status: 400 },
+          );
+        }
+
+        const response = await market.auth.getUserInfo(token);
+        return NextResponse.json(response);
+      } catch (error) {
+        console.error('[MarketOIDC] Failed to proxy userinfo request:', error);
+        return NextResponse.json(
+          {
+            error: 'userinfo_proxy_failed',
+            message: error instanceof Error ? error.message : 'Unknown error',
+            status: 'error',
+          },
+          { status: 500 },
+        );
+      }
+    }
+
+    default: {
+      return NextResponse.json(
+        {
+          error: 'unsupported_endpoint',
+          message: 'Requested endpoint is not supported.',
+          status: 'error',
+        },
+        { status: 404 },
+      );
+    }
+  }
+};
+
+export const GET = (req: NextRequest, context: RouteContext) => handleProxy(req, context);
+export const POST = (req: NextRequest, context: RouteContext) => handleProxy(req, context);
+
+export const dynamic = 'force-dynamic';

package/src/app/[variants]/(main)/(mobile)/me/settings/features/useCategory.tsx

@@ -1,6 +1,7 @@
 import { Bot, Brain, Info, Mic2, Settings2, Sparkles } from 'lucide-react';
 import { useRouter } from 'next/navigation';
 import { useTranslation } from 'react-i18next';
+
 import { CellProps } from '@/components/Cell';
 import { isDeprecatedEdition } from '@/const/version';
 import { SettingsTabs } from '@/store/global/initialState';

package/src/app/[variants]/(main)/_layout/Desktop/SideBar/PinList/index.tsx

@@ -82,12 +82,14 @@ const PinList = () => {
     hasList && (
       <>
         <Divider style={{ marginBottom: 8, marginTop: 4 }} />
-        <ScrollShadow height={"100%"} hideScrollBar={true} size={40}>
+        <ScrollShadow height={'100%'} hideScrollBar={true} size={40}>
           <Flexbox gap={12} style={{ padding: '0' }}>
             {list.map((item, index) => (
               <Flexbox key={item.id} style={{ position: 'relative' }}>
                 <Tooltip
-                  hotkey={index < 9 ? hotkey.replaceAll(KeyEnum.Number, String(index + 1)) : undefined}
+                  hotkey={
+                    index < 9 ? hotkey.replaceAll(KeyEnum.Number, String(index + 1)) : undefined
+                  }
                   placement={'right'}
                   title={sessionHelpers.getTitle(item.meta)}
                 >