feat: import Feishu document links before send

api/server/controllers/FeishuController.js

@@ -0,0 +1,68 @@
+const { importFeishuDocs } = require('@librechat/api');
+const { parseFeishuAllowedHosts } = require('librechat-data-provider');
+const { logger } = require('@librechat/data-schemas');
+const { createFile } = require('~/models');
+const { exchangeOboToken } = require('~/server/services/OboTokenService');
+const { getRetentionExpiry } = require('~/server/services/Files/retention');
+
+const isEnabled = (value) => value === true || String(value).toLowerCase() === 'true';
+
+function parseMaxBytes(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function normalizeUser(user) {
+  return {
+    ...user,
+    id: user?.id ?? user?._id?.toString?.(),
+  };
+}
+
+async function importFeishuDocsController(req, res) {
+  const urls = req.body?.urls;
+  if (!Array.isArray(urls) || urls.length === 0 || urls.some((url) => typeof url !== 'string')) {
+    return res.status(400).json({
+      code: 'FEISHU_INVALID_REQUEST',
+      message: 'A non-empty urls array is required',
+    });
+  }
+
+  try {
+    const result = await importFeishuDocs({
+      urls,
+      user: normalizeUser(req.user),
+      config: {
+        enabled: isEnabled(process.env.FEISHU_DOC_IMPORT_ENABLED),
+        oboScope: process.env.FEISHU_DOC_OBO_SCOPE ?? '',
+        apiBaseUrl: process.env.FEISHU_DOC_API_BASE_URL ?? '',
+        allowedHostSuffixes: parseFeishuAllowedHosts(process.env.FEISHU_DOC_ALLOWED_HOSTS),
+        maxBytes: parseMaxBytes(process.env.FEISHU_DOC_IMPORT_MAX_BYTES),
+      },
+      deps: {
+        createFile,
+        exchangeOboToken,
+        getRetentionExpiry: () => getRetentionExpiry(req),
+      },
+    });
+
+    return res.status(200).json(result);
+  } catch (error) {
+    const code = error?.code ?? 'FEISHU_IMPORT_FAILED';
+    const statusCode = Number.isInteger(error?.statusCode) ? error.statusCode : 500;
+    const message = error?.message ?? 'Failed to import Feishu document';
+
+    if (statusCode >= 500) {
+      logger.error('[importFeishuDocsController] Failed to import Feishu document:', error);
+    }
+
+    return res.status(statusCode).json({
+      code,
+      message,
+    });
+  }
+}
+
+module.exports = {
+  importFeishuDocsController,
+};

api/server/experimental.js

@@ -391,6 +391,7 @@ if (cluster.isMaster) {
     app.use('/api/models', routes.models);
     app.use('/api/config', preAuthTenantMiddleware, optionalJwtAuth, routes.config);
     app.use('/api/assistants', routes.assistants);
+    app.use('/api/feishu', routes.feishu);
     app.use('/api/files', await routes.files.initialize());
     app.use('/images/', createValidateImageRequest(appConfig.secureImageLinks), routes.staticRoute);
     app.use('/api/share', routes.share);

api/server/index.js

@@ -234,6 +234,7 @@ const startServer = async () => {
   app.use('/api/models', routes.models);
   app.use('/api/config', preAuthTenantMiddleware, optionalJwtAuth, routes.config);
   app.use('/api/assistants', routes.assistants);
+  app.use('/api/feishu', routes.feishu);
   app.use('/api/files', await routes.files.initialize());
   app.use('/images/', createValidateImageRequest(appConfig.secureImageLinks), routes.staticRoute);
   app.use('/api/share', preAuthTenantMiddleware, routes.share);

api/server/routes/__tests__/config.spec.js

@@ -159,6 +159,7 @@ describe('GET /api/config', () => {
       expect(response.body).not.toHaveProperty('bundlerURL');
       expect(response.body).not.toHaveProperty('staticBundlerURL');
       expect(response.body).not.toHaveProperty('sharePointFilePickerEnabled');
+      expect(response.body).not.toHaveProperty('feishuDocImportEnabled');
       expect(response.body).not.toHaveProperty('sharePointBaseUrl');
       expect(response.body).not.toHaveProperty('sharePointPickerGraphScope');
       expect(response.body).not.toHaveProperty('sharePointPickerSharePointScope');

api/server/routes/config.js

@@ -26,6 +26,7 @@ const publicSharedLinksEnabled =
   sharedLinksEnabled && isEnabled(process.env.ALLOW_SHARED_LINKS_PUBLIC);
 
 const sharePointFilePickerEnabled = isEnabled(process.env.ENABLE_SHAREPOINT_FILEPICKER);
+const feishuDocImportEnabled = isEnabled(process.env.FEISHU_DOC_IMPORT_ENABLED);
 const openidReuseTokens = isEnabled(process.env.OPENID_REUSE_TOKENS);
 
 /**
@@ -269,6 +270,7 @@ router.get('/', async function (req, res) {
       bundlerURL: process.env.SANDPACK_BUNDLER_URL,
       staticBundlerURL: process.env.SANDPACK_STATIC_BUNDLER_URL,
       sharePointFilePickerEnabled,
+      feishuDocImportEnabled,
       sharePointBaseUrl: process.env.SHAREPOINT_BASE_URL,
       sharePointPickerGraphScope: process.env.SHAREPOINT_PICKER_GRAPH_SCOPE,
       sharePointPickerSharePointScope: process.env.SHAREPOINT_PICKER_SHAREPOINT_SCOPE,

api/server/routes/feishu.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const middleware = require('~/server/middleware');
+const { importFeishuDocsController } = require('~/server/controllers/FeishuController');
+
+const router = express.Router();
+
+router.post(
+  '/docs/import',
+  middleware.requireJwtAuth,
+  middleware.configMiddleware,
+  middleware.checkBan,
+  middleware.uaParser,
+  importFeishuDocsController,
+);
+
+module.exports = router;

api/server/routes/feishu.spec.js

@@ -0,0 +1,147 @@
+const express = require('express');
+const request = require('supertest');
+
+const mockImportFeishuDocs = jest.fn();
+const mockCreateFile = jest.fn();
+const mockExchangeOboToken = jest.fn();
+const mockGetRetentionExpiry = jest.fn();
+
+jest.mock('@librechat/api', () => ({
+  importFeishuDocs: (...args) => mockImportFeishuDocs(...args),
+}));
+
+jest.mock('~/models', () => ({
+  createFile: (...args) => mockCreateFile(...args),
+}));
+
+jest.mock('~/server/services/OboTokenService', () => ({
+  exchangeOboToken: (...args) => mockExchangeOboToken(...args),
+}));
+
+jest.mock('~/server/services/Files/retention', () => ({
+  getRetentionExpiry: (...args) => mockGetRetentionExpiry(...args),
+}));
+
+jest.mock('~/server/middleware', () => {
+  const pass = (req, res, next) => next();
+  return {
+    configMiddleware: pass,
+    checkBan: pass,
+    uaParser: pass,
+    requireJwtAuth: (req, res, next) => {
+      if (req.headers.authorization !== 'Bearer ok') {
+        return res.status(401).json({ message: 'Unauthorized' });
+      }
+
+      req.user = {
+        id: 'user-1',
+        provider: 'openid',
+        openidId: 'oidc-subject',
+        tenantId: 'tenant-1',
+        federatedTokens: {
+          access_token: 'archegate-token',
+        },
+      };
+      return next();
+    },
+  };
+});
+
+describe('Feishu routes', () => {
+  let app;
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env = {
+      ...originalEnv,
+      FEISHU_DOC_IMPORT_ENABLED: 'true',
+      FEISHU_DOC_OBO_SCOPE: 'Feishu.Docs.Read',
+      FEISHU_DOC_API_BASE_URL: 'https://open.feishu.cn',
+      FEISHU_DOC_ALLOWED_HOSTS: 'feishu.cn,larksuite.com',
+      FEISHU_DOC_IMPORT_MAX_BYTES: '1048576',
+    };
+    mockGetRetentionExpiry.mockResolvedValue({ expiredAt: new Date('2026-06-10T00:00:00.000Z') });
+    mockImportFeishuDocs.mockResolvedValue({ files: [], skipped: [] });
+
+    const feishuRouter = require('./feishu');
+    app = express();
+    app.use(express.json());
+    app.use('/api/feishu', feishuRouter);
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    jest.resetModules();
+  });
+
+  test('requires authentication', async () => {
+    await request(app)
+      .post('/api/feishu/docs/import')
+      .send({ urls: ['https://archebase.feishu.cn/wiki/QcXRwepEGiApKykeshKc0T5KnGG'] })
+      .expect(401);
+
+    expect(mockImportFeishuDocs).not.toHaveBeenCalled();
+  });
+
+  test('passes import config and dependencies to the Feishu import service', async () => {
+    const response = await request(app)
+      .post('/api/feishu/docs/import')
+      .set('Authorization', 'Bearer ok')
+      .send({ urls: ['https://archebase.feishu.cn/wiki/QcXRwepEGiApKykeshKc0T5KnGG'] })
+      .expect(200);
+
+    expect(response.body).toEqual({ files: [], skipped: [] });
+    expect(mockImportFeishuDocs).toHaveBeenCalledWith(
+      expect.objectContaining({
+        urls: ['https://archebase.feishu.cn/wiki/QcXRwepEGiApKykeshKc0T5KnGG'],
+        user: expect.objectContaining({ id: 'user-1', provider: 'openid' }),
+        config: {
+          enabled: true,
+          oboScope: 'Feishu.Docs.Read',
+          apiBaseUrl: 'https://open.feishu.cn',
+          allowedHostSuffixes: ['feishu.cn', 'larksuite.com'],
+          maxBytes: 1048576,
+        },
+        deps: expect.objectContaining({
+          createFile: expect.any(Function),
+          exchangeOboToken: expect.any(Function),
+          getRetentionExpiry: expect.any(Function),
+        }),
+      }),
+    );
+  });
+
+  test('maps Feishu import errors to stable HTTP responses', async () => {
+    mockImportFeishuDocs.mockRejectedValue({
+      code: 'FEISHU_PERMISSION_DENIED',
+      statusCode: 403,
+      message: 'permission denied',
+    });
+
+    const response = await request(app)
+      .post('/api/feishu/docs/import')
+      .set('Authorization', 'Bearer ok')
+      .send({ urls: ['https://archebase.feishu.cn/wiki/QcXRwepEGiApKykeshKc0T5KnGG'] })
+      .expect(403);
+
+    expect(response.body).toEqual({
+      code: 'FEISHU_PERMISSION_DENIED',
+      message: 'permission denied',
+    });
+  });
+
+  test('rejects missing url arrays before calling the import service', async () => {
+    const response = await request(app)
+      .post('/api/feishu/docs/import')
+      .set('Authorization', 'Bearer ok')
+      .send({ urls: [] })
+      .expect(400);
+
+    expect(response.body).toEqual({
+      code: 'FEISHU_INVALID_REQUEST',
+      message: 'A non-empty urls array is required',
+    });
+    expect(mockImportFeishuDocs).not.toHaveBeenCalled();
+  });
+});

api/server/routes/index.js

@@ -8,6 +8,7 @@ const adminGroups = require('./admin/groups');
 const adminRoles = require('./admin/roles');
 const adminUsers = require('./admin/users');
 const endpoints = require('./endpoints');
+const feishu = require('./feishu');
 const staticRoute = require('./static');
 const messages = require('./messages');
 const memories = require('./memories');
@@ -68,6 +69,7 @@ module.exports = {
   messages,
   memories,
   endpoints,
+  feishu,
   assistants,
   categories,
   staticRoute,

client/src/data-provider/Feishu/index.ts

@@ -0,0 +1 @@
+export * from './mutations';

client/src/data-provider/Feishu/mutations.ts

@@ -0,0 +1,15 @@
+import { useMutation } from '@tanstack/react-query';
+import { MutationKeys, dataService } from 'librechat-data-provider';
+import type * as t from 'librechat-data-provider';
+import type { UseMutationResult } from '@tanstack/react-query';
+
+export const useImportFeishuDocsMutation = (): UseMutationResult<
+  t.FeishuDocImportResponse,
+  unknown,
+  t.FeishuDocImportRequest,
+  unknown
+> => {
+  return useMutation([MutationKeys.feishuDocImport], {
+    mutationFn: (body: t.FeishuDocImportRequest) => dataService.importFeishuDocs(body),
+  });
+};

client/src/data-provider/index.ts

@@ -3,6 +3,7 @@ export * from './Agents';
 export * from './Endpoints';
 export * from './Skills';
 export * from './Files';
+export * from './Feishu';
 /* Memories */
 export * from './Memories';
 export * from './Messages';