@lobehub/lobehub 2.0.0-next.217 → 2.0.0-next.219

package/src/features/EditorModal/TextareCanvas.tsx

@@ -0,0 +1,28 @@
+import { TextArea } from '@lobehub/ui';
+import { FC } from 'react';
+
+interface EditorCanvasProps {
+  onChange?: (value: string) => void;
+  value?: string;
+}
+
+const EditorCanvas: FC<EditorCanvasProps> = ({ value, onChange }) => {
+  return (
+    <TextArea
+      onChange={(e) => {
+        onChange?.(e.target.value);
+      }}
+      style={{
+        cursor: 'text',
+        maxHeight: '80vh',
+        minHeight: '50vh',
+        overflowY: 'auto',
+        padding: 16,
+      }}
+      value={value}
+      variant={'borderless'}
+    />
+  );
+};
+
+export default EditorCanvas;

package/src/{app/[variants]/(main)/memory/features/EditableModal → features/EditorModal}/Typobar.tsx

@@ -4,7 +4,6 @@ import {
   ChatInputActionBar,
   ChatInputActions,
   type ChatInputActionsProps,
-  CodeLanguageSelect,
 } from '@lobehub/editor/react';
 import { cssVar } from 'antd-style';
 import {
@@ -119,16 +118,6 @@ const TypoBar = memo<{ editor?: IEditor }>(({ editor }) => {
           label: t('typobar.codeblock'),
           onClick: editorState.codeblock,
         },
-        editorState.isCodeblock && {
-          children: (
-            <CodeLanguageSelect
-              onSelect={(value) => editorState.updateCodeblockLang(value)}
-              value={editorState.codeblockLang}
-            />
-          ),
-          disabled: !editorState.isCodeblock,
-          key: 'codeblockLang',
-        },
       ].filter(Boolean) as ChatInputActionsProps['items'],
     [editorState],
   );

package/src/features/EditorModal/index.tsx

@@ -0,0 +1,51 @@
+import { Modal, ModalProps, createRawModal } from '@lobehub/ui';
+import { memo, useState } from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useUserStore } from '@/store/user';
+import { labPreferSelectors } from '@/store/user/slices/preference/selectors';
+
+import EditorCanvas from './EditorCanvas';
+import TextareCanvas from './TextareCanvas';
+
+interface EditorModalProps extends ModalProps {
+  onConfirm?: (value: string) => Promise<void>;
+  value?: string;
+}
+
+export const EditorModal = memo<EditorModalProps>(({ value, onConfirm, ...rest }) => {
+  const [confirmLoading, setConfirmLoading] = useState(false);
+  const { t } = useTranslation('common');
+  const [v, setV] = useState(value);
+  const enableRichRender = useUserStore(labPreferSelectors.enableInputMarkdown);
+
+  const Canvas = enableRichRender ? EditorCanvas : TextareCanvas;
+
+  return (
+    <Modal
+      cancelText={t('cancel')}
+      closable={false}
+      confirmLoading={confirmLoading}
+      destroyOnHidden
+      okText={t('ok')}
+      onOk={async () => {
+        setConfirmLoading(true);
+        await onConfirm?.(v || '');
+        setConfirmLoading(false);
+      }}
+      styles={{
+        body: {
+          overflow: 'hidden',
+          padding: 0,
+        },
+      }}
+      title={null}
+      width={'min(90vw, 920px)'}
+      {...rest}
+    >
+      <Canvas onChange={(v) => setV(v)} value={v} />
+    </Modal>
+  );
+});
+
+export const createEditorModal = (props: EditorModalProps) => createRawModal(EditorModal, props);

package/src/features/PageEditor/Copilot/TopicSelector/Actions.tsx

@@ -11,7 +11,7 @@ const Actions = memo<ActionsProps>(({ dropdownMenu }) => {
     return null;
 
   return (
-    <DropdownMenu items={dropdownMenu}>
+    <DropdownMenu items={dropdownMenu} nativeButton={false}>
       <ActionIcon icon={MoreHorizontalIcon} size={'small'} />
     </DropdownMenu>
   );

package/src/features/PageEditor/EditorCanvas/InlineToolbar.tsx

@@ -7,12 +7,7 @@ import {
   INSERT_HEADING_COMMAND,
   getHotkeyById,
 } from '@lobehub/editor';
-import {
-  ChatInputActions,
-  type ChatInputActionsProps,
-  CodeLanguageSelect,
-  FloatActions,
-} from '@lobehub/editor/react';
+import { ChatInputActions, type ChatInputActionsProps, FloatActions } from '@lobehub/editor/react';
 import { Block } from '@lobehub/ui';
 import { createStaticStyles, cssVar } from 'antd-style';
 import {
@@ -283,17 +278,6 @@ const TypoBar = memo<ToolbarProps>(({ floating, style, className }) => {
         label: t('typobar.codeblock'),
         onClick: editorState.codeblock,
       },
-      !floating &&
-        editorState.isCodeblock && {
-          children: (
-            <CodeLanguageSelect
-              onSelect={(value) => editorState.updateCodeblockLang(value)}
-              value={editorState.codeblockLang}
-            />
-          ),
-          disabled: !editorState.isCodeblock,
-          key: 'codeblockLang',
-        },
     ];
 
     return baseItems.filter(Boolean) as ChatInputActionsProps['items'];

package/src/features/ResourceManager/components/Explorer/ItemDropdown/DropdownMenu.tsx

@@ -10,7 +10,7 @@ interface DropdownMenuProps {
 
 const DropdownMenu = memo<DropdownMenuProps>(({ items, className }) => {
   return (
-    <DropdownMenuUI items={items}>
+    <DropdownMenuUI items={items} nativeButton={false}>
       <ActionIcon className={className} icon={MoreHorizontalIcon} size={'small'} />
     </DropdownMenuUI>
   );

package/src/features/User/UserPanel/ThemeButton.tsx

@@ -43,7 +43,7 @@ const ThemeButton: FC<{ placement?: DropdownMenuProps['placement']; size?: numbe
   );
 
   return (
-    <DropdownMenu items={items} placement={placement}>
+    <DropdownMenu items={items} nativeButton={false} placement={placement}>
       <ActionIcon
         icon={themeIcons[(theme as 'dark' | 'light' | 'system') || 'system']}
         size={size || { blockSize: 32, size: 16 }}

package/src/server/routers/tools/market.ts

@@ -1,14 +1,13 @@
 import { type CodeInterpreterToolName, MarketSDK } from '@lobehub/market-sdk';
 import { TRPCError } from '@trpc/server';
 import debug from 'debug';
+import { sha256 } from 'js-sha256';
 import { z } from 'zod';
 
-import { DocumentModel } from '@/database/models/document';
-import { FileModel } from '@/database/models/file';
 import { type ToolCallContent } from '@/libs/mcp';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { marketUserInfo, serverDatabase, telemetry } from '@/libs/trpc/lambda/middleware';
-import { generateTrustedClientToken } from '@/libs/trusted-client';
+import { generateTrustedClientToken, isTrustedClientEnabled } from '@/libs/trusted-client';
 import { FileS3 } from '@/server/modules/S3';
 import { DiscoverService } from '@/server/services/discover';
 import { FileService } from '@/server/services/file';
@@ -69,21 +68,13 @@ const callCodeInterpreterToolSchema = z.object({
   userId: z.string(),
 });
 
-// Schema for getting export file upload URL
-const getExportFileUploadUrlSchema = z.object({
+// Schema for export and upload file (combined operation)
+const exportAndUploadFileSchema = z.object({
   filename: z.string(),
+  path: z.string(),
   topicId: z.string(),
 });
 
-// Schema for saving exported file content to document
-const saveExportedFileContentSchema = z.object({
-  content: z.string(),
-  fileId: z.string(),
-  fileType: z.string(),
-  filename: z.string(),
-  url: z.string(),
-});
-
 // Schema for cloud MCP endpoint call
 const callCloudMcpEndpointSchema = z.object({
   apiParams: z.record(z.any()),
@@ -94,8 +85,7 @@ const callCloudMcpEndpointSchema = z.object({
 
 // ============================== Type Exports ==============================
 export type CallCodeInterpreterToolInput = z.infer<typeof callCodeInterpreterToolSchema>;
-export type GetExportFileUploadUrlInput = z.infer<typeof getExportFileUploadUrlSchema>;
-export type SaveExportedFileContentInput = z.infer<typeof saveExportedFileContentSchema>;
+export type ExportAndUploadFileInput = z.infer<typeof exportAndUploadFileSchema>;
 
 export interface CallToolResult {
   error?: {
@@ -107,22 +97,16 @@ export interface CallToolResult {
   success: boolean;
 }
 
-export interface GetExportFileUploadUrlResult {
-  downloadUrl: string;
-  error?: {
-    message: string;
-  };
-  key: string;
-  success: boolean;
-  uploadUrl: string;
-}
-
-export interface SaveExportedFileContentResult {
-  documentId?: string;
+export interface ExportAndUploadFileResult {
   error?: {
     message: string;
   };
+  fileId?: string;
+  filename: string;
+  mimeType?: string;
+  size?: number;
   success: boolean;
+  url?: string;
 }
 
 // ============================== Router ==============================
@@ -140,17 +124,26 @@ export const marketRouter = router({
       let result: { content: string; state: any; success: boolean } | undefined;
 
       try {
-        // Query user_settings to get market.accessToken
-        const userState = await ctx.userModel.getUserState(async () => ({}));
-        const userAccessToken = userState.settings?.market?.accessToken;
-
-        log('callCloudMcpEndpoint: userAccessToken exists=%s', !!userAccessToken);
-
-        if (!userAccessToken) {
-          throw new TRPCError({
-            code: 'UNAUTHORIZED',
-            message: 'User access token not found. Please sign in to Market first.',
-          });
+        // Check if trusted client is enabled - if so, we don't need user's accessToken
+        const trustedClientEnabled = isTrustedClientEnabled();
+
+        let userAccessToken: string | undefined;
+
+        if (!trustedClientEnabled) {
+          // Query user_settings to get market.accessToken only if trusted client is not enabled
+          const userState = await ctx.userModel.getUserState(async () => ({}));
+          userAccessToken = userState.settings?.market?.accessToken;
+
+          log('callCloudMcpEndpoint: userAccessToken exists=%s', !!userAccessToken);
+
+          if (!userAccessToken) {
+            throw new TRPCError({
+              code: 'UNAUTHORIZED',
+              message: 'User access token not found. Please sign in to Market first.',
+            });
+          }
+        } else {
+          log('callCloudMcpEndpoint: using trusted client authentication');
         }
 
         const cloudResult = await ctx.discoverService.callCloudMcpEndpoint({
@@ -277,99 +270,122 @@ export const marketRouter = router({
     }),
 
   /**
-   * Generate a pre-signed upload URL for exporting files from sandbox
+   * Export a file from sandbox and upload to S3, then create a persistent file record
+   * This combines the previous getExportFileUploadUrl + callCodeInterpreterTool + createFileRecord flow
+   * Returns a permanent /f/:id URL instead of a temporary pre-signed URL
    */
-  getExportFileUploadUrl: marketToolProcedure
-    .input(getExportFileUploadUrlSchema)
-    .mutation(async ({ input }) => {
-      const { filename, topicId } = input;
+  exportAndUploadFile: marketToolProcedure
+    .input(exportAndUploadFileSchema)
+    .mutation(async ({ input, ctx }) => {
+      const { path, filename, topicId } = input;
 
-      log('Generating export file upload URL for: %s in topic: %s', filename, topicId);
+      log('Exporting and uploading file: %s from path: %s in topic: %s', filename, path, topicId);
 
       try {
         const s3 = new FileS3();
 
+        // Use date-based sharding for privacy compliance (GDPR, CCPA)
+        const today = new Date().toISOString().split('T')[0];
+
         // Generate a unique key for the exported file
-        const key = `code-interpreter-exports/${topicId}/${filename}`;
+        const key = `code-interpreter-exports/${today}/${topicId}/${filename}`;
 
-        // Generate pre-signed upload URL
+        // Step 1: Generate pre-signed upload URL
         const uploadUrl = await s3.createPreSignedUrl(key);
-
-        // Generate download URL (pre-signed for preview)
-        const downloadUrl = await s3.createPreSignedUrlForPreview(key);
-
         log('Generated upload URL for key: %s', key);
 
-        return {
-          downloadUrl,
-          key,
-          success: true,
-          uploadUrl,
-        } as GetExportFileUploadUrlResult;
-      } catch (error) {
-        log('Error generating export file upload URL: %O', error);
+        // Step 2: Generate trusted client token if user info is available
+        const trustedClientToken = ctx.marketUserInfo
+          ? generateTrustedClientToken(ctx.marketUserInfo)
+          : undefined;
+
+        // Only require user accessToken if trusted client is not available
+        let userAccessToken: string | undefined;
+        if (!trustedClientToken) {
+          const userState = await ctx.userModel.getUserState(async () => ({}));
+          userAccessToken = userState.settings?.market?.accessToken;
+
+          if (!userAccessToken) {
+            return {
+              error: { message: 'User access token not found. Please sign in to Market first.' },
+              filename,
+              success: false,
+            } as ExportAndUploadFileResult;
+          }
+        } else {
+          log('Using trusted client authentication for exportAndUploadFile');
+        }
 
-        return {
-          downloadUrl: '',
-          error: {
-            message: (error as Error).message,
-          },
-          key: '',
-          success: false,
-          uploadUrl: '',
-        } as GetExportFileUploadUrlResult;
-      }
-    }),
+        // Initialize MarketSDK
+        const market = new MarketSDK({
+          accessToken: userAccessToken,
+          baseURL: process.env.NEXT_PUBLIC_MARKET_BASE_URL,
+          trustedClientToken,
+        });
 
-  /**
-   * Save exported file content to documents table
-   */
-  saveExportedFileContent: marketToolProcedure
-    .input(saveExportedFileContentSchema)
-    .mutation(async ({ ctx, input }) => {
-      const { content, fileId, fileType, filename, url } = input;
+        // Step 3: Call sandbox's exportFile tool with the upload URL
+        const response = await market.plugins.runBuildInTool(
+          'exportFile',
+          { path, uploadUrl },
+          { topicId, userId: ctx.userId },
+        );
 
-      log('Saving exported file content: fileId=%s, filename=%s', fileId, filename);
+        log('Sandbox exportFile response: %O', response);
 
-      try {
-        const documentModel = new DocumentModel(ctx.serverDB, ctx.userId);
-        const fileModel = new FileModel(ctx.serverDB, ctx.userId);
+        if (!response.success) {
+          return {
+            error: { message: response.error?.message || 'Failed to export file from sandbox' },
+            filename,
+            success: false,
+          } as ExportAndUploadFileResult;
+        }
+
+        const result = response.data?.result;
+        const uploadSuccess = result?.success !== false;
 
-        // Verify the file exists
-        const file = await fileModel.findById(fileId);
-        if (!file) {
+        if (!uploadSuccess) {
           return {
-            error: { message: 'File not found' },
+            error: { message: result?.error || 'Failed to upload file from sandbox' },
+            filename,
             success: false,
-          } as SaveExportedFileContentResult;
+          } as ExportAndUploadFileResult;
         }
 
-        // Create document record with the file content
-        const document = await documentModel.create({
-          content,
-          fileId,
-          fileType,
-          filename,
-          source: url,
-          sourceType: 'file',
-          title: filename,
-          totalCharCount: content.length,
-          totalLineCount: content.split('\n').length,
+        // Step 4: Get file metadata from S3 to verify upload and get actual size
+        const metadata = await s3.getFileMetadata(key);
+        const fileSize = metadata.contentLength;
+        const mimeType = metadata.contentType || result?.mimeType || 'application/octet-stream';
+
+        // Step 5: Create persistent file record using FileService
+        // Generate a simple hash from the key (since we don't have the actual file content)
+        const fileHash = sha256(key + Date.now().toString());
+
+        const { fileId, url } = await ctx.fileService.createFileRecord({
+          fileHash,
+          fileType: mimeType,
+          name: filename,
+          size: fileSize,
+          url: key, // Store S3 key
         });
 
-        log('Created document for exported file: documentId=%s, fileId=%s', document.id, fileId);
+        log('Created file record: fileId=%s, url=%s', fileId, url);
 
         return {
-          documentId: document.id,
+          fileId,
+          filename,
+          mimeType,
+          size: fileSize,
           success: true,
-        } as SaveExportedFileContentResult;
+          url, // This is the permanent /f/:id URL
+        } as ExportAndUploadFileResult;
       } catch (error) {
-        log('Error saving exported file content: %O', error);
+        log('Error in exportAndUploadFile: %O', error);
 
         return {
           error: { message: (error as Error).message },
+          filename,
           success: false,
-        } as SaveExportedFileContentResult;
+        } as ExportAndUploadFileResult;
       }
     }),
 });

package/src/server/services/discover/index.ts

@@ -149,7 +149,7 @@ export class DiscoverService {
     apiParams: Record<string, any>;
     identifier: string;
     toolName: string;
-    userAccessToken: string;
+    userAccessToken?: string;
   }) {
     log('callCloudMcpEndpoint: params=%O', {
       apiParams: params.apiParams,
@@ -159,7 +159,14 @@ export class DiscoverService {
     });
 
     try {
-      // Call cloud gateway with user access token in Authorization header
+      // Build headers - only include Authorization if userAccessToken is provided
+      // When userAccessToken is not provided, MarketSDK will use trustedClientToken for authentication
+      const headers: Record<string, string> = {};
+      if (params.userAccessToken) {
+        headers.Authorization = `Bearer ${params.userAccessToken}`;
+      }
+
+      // Call cloud gateway with optional user access token in Authorization header
       const result = await this.market.plugins.callCloudGateway(
         {
           apiParams: params.apiParams,
@@ -167,9 +174,7 @@ export class DiscoverService {
           toolName: params.toolName,
         },
         {
-          headers: {
-            Authorization: `Bearer ${params.userAccessToken}`,
-          },
+          headers,
         },
       );
 

package/src/services/codeInterpreter.ts

@@ -2,10 +2,8 @@ import { toolsClient } from '@/libs/trpc/client';
 import type {
   CallCodeInterpreterToolInput,
   CallToolResult,
-  GetExportFileUploadUrlInput,
-  GetExportFileUploadUrlResult,
-  SaveExportedFileContentInput,
-  SaveExportedFileContentResult,
+  ExportAndUploadFileInput,
+  ExportAndUploadFileResult,
 } from '@/server/routers/tools/market';
 import { useUserStore } from '@/store/user';
 import { settingsSelectors } from '@/store/user/slices/settings/selectors/settings';
@@ -44,31 +42,25 @@ class CodeInterpreterService {
   }
 
   /**
-   * Get a pre-signed upload URL for exporting a file from the sandbox
+   * Export a file from sandbox and upload to S3, then create a persistent file record
+   * This is a single call that combines: getUploadUrl + callTool(exportFile) + createFileRecord
+   * Returns a permanent /f/:id URL instead of a temporary pre-signed URL
+   * @param path - The file path in the sandbox
    * @param filename - The name of the file to export
    * @param topicId - The topic ID for organizing files
    */
-  async getExportFileUploadUrl(
+  async exportAndUploadFile(
+    path: string,
     filename: string,
     topicId: string,
-  ): Promise<GetExportFileUploadUrlResult> {
-    const input: GetExportFileUploadUrlInput = {
+  ): Promise<ExportAndUploadFileResult> {
+    const input: ExportAndUploadFileInput = {
       filename,
+      path,
       topicId,
     };
 
-    return toolsClient.market.getExportFileUploadUrl.mutate(input);
-  }
-
-  /**
-   * Save exported file content to documents table
-   * This creates a document record linked to the file for content retrieval
-   * @param params - File content and metadata
-   */
-  async saveExportedFileContent(
-    params: SaveExportedFileContentInput,
-  ): Promise<SaveExportedFileContentResult> {
-    return toolsClient.market.saveExportedFileContent.mutate(params);
+    return toolsClient.market.exportAndUploadFile.mutate(input);
   }
 }