@lobehub/chat 1.39.2 → 1.40.0

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

@@ -0,0 +1,196 @@
+import dayjs from 'dayjs';
+import matter from 'gray-matter';
+import { markdownToTxt } from 'markdown-to-txt';
+import semver from 'semver';
+import urlJoin from 'url-join';
+
+import { Locales } from '@/locales/resources';
+import { ChangelogIndexItem } from '@/types/changelog';
+
+const BASE_URL = 'https://raw.githubusercontent.com';
+const LAST_MODIFIED = new Date().toISOString();
+
+const docCdnPrefix = process.env.DOC_S3_PUBLIC_DOMAIN || '';
+
+export interface ChangelogConfig {
+  branch: string;
+  cdnPath: string;
+  changelogPath: string;
+  docsPath: string;
+  majorVersion: number;
+  repo: string;
+  type: 'cloud' | 'community';
+  user: string;
+}
+
+export class ChangelogService {
+  cdnUrls: {
+    [key: string]: string;
+  } = {};
+  config: ChangelogConfig = {
+    branch: process.env.DOCS_BRANCH || 'main',
+    cdnPath: 'docs/.cdn.cache.json',
+    changelogPath: 'changelog',
+    docsPath: 'docs/changelog',
+    majorVersion: 1,
+    repo: 'lobe-chat',
+    type: 'cloud',
+    user: 'lobehub',
+  };
+
+  async getLatestChangelogId() {
+    const index = await this.getChangelogIndex();
+    return index[0]?.id;
+  }
+
+  async getChangelogIndex(): Promise<ChangelogIndexItem[]> {
+    try {
+      const url = this.genUrl(urlJoin(this.config.docsPath, 'index.json'));
+
+      const res = await fetch(url);
+
+      const data = await res.json();
+
+      return this.mergeChangelogs(data.cloud, data.community).slice(0, 5);
+    } catch (e) {
+      console.error('Error getting changelog lists:', e);
+      return false as any;
+    }
+  }
+
+  async getIndexItemById(id: string) {
+    const index = await this.getChangelogIndex();
+    return index.find((item) => item.id === id);
+  }
+
+  async getPostById(id: string, options?: { locale?: Locales }) {
+    await this.cdnInit();
+    try {
+      const post = await this.getIndexItemById(id);
+
+      const filename = options?.locale === 'en-US' ? `${id}.mdx` : `${id}.zh-CN.mdx`;
+      const url = this.genUrl(urlJoin(this.config.docsPath, filename));
+
+      const response = await fetch(url);
+      const text = await response.text();
+      const { data, content } = matter(text);
+
+      const regex = /^#\s(.+)/;
+      const match = regex.exec(content.trim());
+      const matches = content.trim().split(regex);
+
+      let description: string;
+
+      if (matches[2]) {
+        description = matches[2] ? matches[2].trim() : '';
+      } else {
+        description = matches[1] ? matches[1].trim() : '';
+      }
+
+      if (docCdnPrefix) {
+        const images = this.extractHttpsLinks(content);
+        for (const url of images) {
+          const cdnUrl = this.replaceCdnUrl(url);
+          if (cdnUrl && url !== cdnUrl) {
+            description = description.replaceAll(url, cdnUrl);
+          }
+        }
+      }
+
+      return {
+        date: post?.date
+          ? new Date(post.date)
+          : data?.date
+            ? new Date(data.date)
+            : new Date(LAST_MODIFIED),
+        description: markdownToTxt(description.replaceAll('\n', '').replaceAll('  ', ' ')).slice(
+          0,
+          160,
+        ),
+        image: post?.image ? this.replaceCdnUrl(post.image) : undefined,
+        tags: ['changelog'],
+        title: match ? match[1] : '',
+        ...data,
+        content: description,
+        rawTitle: match ? match[1] : '',
+      };
+    } catch {
+      console.error('Error getting changlog post by id', id);
+      return false as any;
+    }
+  }
+
+  private mergeChangelogs(
+    cloud: ChangelogIndexItem[],
+    community: ChangelogIndexItem[],
+  ): ChangelogIndexItem[] {
+    if (this.config.type === 'community') {
+      return community;
+    }
+
+    const merged = [...community];
+
+    for (const cloudItem of cloud) {
+      const index = merged.findIndex((item) => item.id === cloudItem.id);
+      if (index !== -1) {
+        merged[index] = cloudItem;
+      } else {
+        merged.push(cloudItem);
+      }
+    }
+
+    return merged
+      .map((item) => ({
+        ...item,
+        date: dayjs(item.date).format('YYYY-MM-DD'),
+        versionRange: this.formatVersionRange(item.versionRange),
+      }))
+      .sort((a, b) => semver.rcompare(a.versionRange[0], b.versionRange[0]));
+  }
+
+  private formatVersionRange(range: string[]): string[] {
+    if (range.length === 1) {
+      return range;
+    }
+
+    const [v1, v2]: any = range.map((v) => semver.parse(v)?.toString());
+
+    const minVersion = semver.lt(v1, v2) ? v1 : v2;
+    const maxVersion = semver.gt(v1, v2) ? v1 : v2;
+
+    return [maxVersion, minVersion];
+  }
+
+  private genUrl(path: string) {
+    return urlJoin(BASE_URL, this.config.user, this.config.repo, this.config.branch, path);
+  }
+
+  private extractHttpsLinks(text: string) {
+    const regex = /https:\/\/[^\s"')>]+/g;
+    const links = text.match(regex);
+    return links || [];
+  }
+
+  private async cdnInit() {
+    if (!docCdnPrefix) return;
+    if (Object.keys(this.cdnUrls).length === 0) {
+      try {
+        const url = this.genUrl(this.config.cdnPath);
+        const res = await fetch(url);
+        const data = await res.json();
+        if (data) {
+          this.cdnUrls = data;
+        }
+      } catch (error) {
+        console.error('Error getting changelog cdn cache:', error);
+      }
+    }
+  }
+
+  private replaceCdnUrl(url: string) {
+    if (!docCdnPrefix || !this.cdnUrls?.[url]) {
+      return url;
+    }
+    return urlJoin(docCdnPrefix, this.cdnUrls[url]);
+  }
+}

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

@@ -1,7 +1,6 @@
 // @vitest-environment node
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { DEFAULT_LANG } from '@/const/locale';
 import { AssistantCategory, PluginCategory } from '@/types/discover';
 
 import { DiscoverService } from './index';

package/src/server/sitemap.ts

@@ -3,6 +3,7 @@ import { MetadataRoute } from 'next';
 import qs from 'query-string';
 import urlJoin from 'url-join';
 
+import { serverFeatureFlags } from '@/config/featureFlags';
 import { DEFAULT_LANG } from '@/const/locale';
 import { SITEMAP_BASE_URL } from '@/const/url';
 import { Locales, locales as allLocales } from '@/locales/resources';
@@ -195,12 +196,14 @@ export class Sitemap {
   }
 
   async getPage(): Promise<MetadataRoute.Sitemap> {
+    const hideDocs = serverFeatureFlags().hideDocs;
     const assistantsCategory = Object.values(AssistantCategory);
     const pluginCategory = Object.values(PluginCategory);
     const modelCategory = await this.discoverService.getProviderList(DEFAULT_LANG);
     return [
       ...this._genSitemap('/', { noLocales: true }),
       ...this._genSitemap('/chat', { noLocales: true }),
+      ...(!hideDocs ? this._genSitemap('/changelog', { noLocales: true }) : []),
       /* ↓ cloud slot ↓ */
 
       /* ↑ cloud slot ↑ */
@@ -227,7 +230,7 @@ export class Sitemap {
         }),
       ),
       ...this._genSitemap('/discover/providers', { changeFrequency: 'daily', priority: 0.7 }),
-    ];
+    ].filter(Boolean);
   }
   getRobots() {
     return [

package/src/services/__tests__/chat.test.ts

@@ -904,7 +904,7 @@ describe('ChatService', () => {
  * initialization of AgentRuntime with different providers
  */
 vi.mock('../_auth', async (importOriginal) => {
-  return await importOriginal();
+  return importOriginal();
 });
 describe('AgentRuntimeOnClient', () => {
   describe('initializeWithClientStore', () => {

package/src/services/__tests__/global.test.ts

@@ -18,6 +18,9 @@ vi.mock('@/libs/trpc/client', () => {
         getGlobalConfig: { query: vi.fn() },
         getDefaultAgentConfig: { query: vi.fn() },
       },
+      appStatus: {
+        getLatestChangelogId: { query: vi.fn() },
+      },
     },
   };
 });
@@ -28,14 +31,14 @@ describe('GlobalService', () => {
       // Arrange
       const mockVersion = '1.0.0';
       (fetch as Mock).mockResolvedValue({
-        json: () => Promise.resolve({ 'dist-tags': { latest: mockVersion } }),
+        json: () => Promise.resolve({ version: mockVersion }),
       });
 
       // Act
       const version = await globalService.getLatestVersion();
 
       // Assert
-      expect(fetch).toHaveBeenCalledWith('https://registry.npmmirror.com/@lobehub/chat');
+      expect(fetch).toHaveBeenCalledWith('https://registry.npmmirror.com/@lobehub/chat/latest');
       expect(version).toBe(mockVersion);
     });
 

package/src/services/_auth.ts

@@ -78,7 +78,7 @@ const createAuthTokenWithPayload = async (payload = {}) => {
   const accessCode = keyVaultsConfigSelectors.password(useUserStore.getState());
   const userId = userProfileSelectors.userId(useUserStore.getState());
 
-  return await createJWT<JWTPayload>({ accessCode, userId, ...payload });
+  return createJWT<JWTPayload>({ accessCode, userId, ...payload });
 };
 
 interface AuthParams {

package/src/services/agent.ts

@@ -1,45 +1,49 @@
 import { lambdaClient } from '@/libs/trpc/client';
 
 class AgentService {
-  async createAgentKnowledgeBase(agentId: string, knowledgeBaseId: string, enabled?: boolean) {
-    return await lambdaClient.agent.createAgentKnowledgeBase.mutate({
+  createAgentKnowledgeBase = async (
+    agentId: string,
+    knowledgeBaseId: string,
+    enabled?: boolean,
+  ) => {
+    return lambdaClient.agent.createAgentKnowledgeBase.mutate({
       agentId,
       enabled,
       knowledgeBaseId,
     });
-  }
+  };
 
-  async deleteAgentKnowledgeBase(agentId: string, knowledgeBaseId: string) {
-    return await lambdaClient.agent.deleteAgentKnowledgeBase.mutate({ agentId, knowledgeBaseId });
-  }
+  deleteAgentKnowledgeBase = async (agentId: string, knowledgeBaseId: string) => {
+    return lambdaClient.agent.deleteAgentKnowledgeBase.mutate({ agentId, knowledgeBaseId });
+  };
 
-  async toggleKnowledgeBase(agentId: string, knowledgeBaseId: string, enabled?: boolean) {
-    return await lambdaClient.agent.toggleKnowledgeBase.mutate({
+  toggleKnowledgeBase = async (agentId: string, knowledgeBaseId: string, enabled?: boolean) => {
+    return lambdaClient.agent.toggleKnowledgeBase.mutate({
       agentId,
       enabled,
       knowledgeBaseId,
     });
-  }
+  };
 
-  async createAgentFiles(agentId: string, fileIds: string[], enabled?: boolean) {
-    return await lambdaClient.agent.createAgentFiles.mutate({ agentId, enabled, fileIds });
-  }
+  createAgentFiles = async (agentId: string, fileIds: string[], enabled?: boolean) => {
+    return lambdaClient.agent.createAgentFiles.mutate({ agentId, enabled, fileIds });
+  };
 
-  async deleteAgentFile(agentId: string, fileId: string) {
-    return await lambdaClient.agent.deleteAgentFile.mutate({ agentId, fileId });
-  }
+  deleteAgentFile = async (agentId: string, fileId: string) => {
+    return lambdaClient.agent.deleteAgentFile.mutate({ agentId, fileId });
+  };
 
-  async toggleFile(agentId: string, fileId: string, enabled?: boolean) {
-    return await lambdaClient.agent.toggleFile.mutate({
+  toggleFile = async (agentId: string, fileId: string, enabled?: boolean) => {
+    return lambdaClient.agent.toggleFile.mutate({
       agentId,
       enabled,
       fileId,
     });
-  }
+  };
 
-  async getFilesAndKnowledgeBases(agentId: string) {
-    return await lambdaClient.agent.getKnowledgeBasesAndFiles.query({ agentId });
-  }
+  getFilesAndKnowledgeBases = async (agentId: string) => {
+    return lambdaClient.agent.getKnowledgeBasesAndFiles.query({ agentId });
+  };
 }
 
 export const agentService = new AgentService();

package/src/services/chat.ts

@@ -499,7 +499,7 @@ class ChatService {
     return this.reorderToolMessages(postMessages);
   };
 
-  private mapTrace(trace?: TracePayload, tag?: TraceTagMap): TracePayload {
+  private mapTrace = (trace?: TracePayload, tag?: TraceTagMap): TracePayload => {
     const tags = sessionMetaSelectors.currentAgentMeta(useSessionStore.getState()).tags || [];
 
     const enabled = preferenceSelectors.userAllowTrace(useUserStore.getState());
@@ -512,7 +512,7 @@ class ChatService {
       tags: [tag, ...(trace?.tags || []), ...tags].filter(Boolean) as string[],
       userId: userProfileSelectors.userId(useUserStore.getState()),
     };
-  }
+  };
 
   /**
    * Fetch chat completion on the client side.

package/src/services/file/ClientS3/index.ts

@@ -17,21 +17,21 @@ export class BrowserS3Storage {
    * @param key 文件 hash
    * @param file File 对象
    */
-  async putObject(key: string, file: File): Promise<void> {
+  putObject = async (key: string, file: File): Promise<void> => {
     try {
       const data = await file.arrayBuffer();
       await set(key, { data, name: file.name, type: file.type }, this.store);
     } catch (e) {
       throw new Error(`Failed to put file ${file.name}: ${(e as Error).message}`);
     }
-  }
+  };
 
   /**
    * 获取文件
    * @param key 文件 hash
    * @returns File 对象
    */
-  async getObject(key: string): Promise<File | undefined> {
+  getObject = async (key: string): Promise<File | undefined> => {
     try {
       const res = await get<{ data: ArrayBuffer; name: string; type: string }>(key, this.store);
       if (!res) return;
@@ -40,19 +40,19 @@ export class BrowserS3Storage {
     } catch (e) {
       throw new Error(`Failed to get object (key=${key}): ${(e as Error).message}`);
     }
-  }
+  };
 
   /**
    * 删除文件
    * @param key 文件 hash
    */
-  async deleteObject(key: string): Promise<void> {
+  deleteObject = async (key: string): Promise<void> => {
     try {
       await del(key, this.store);
     } catch (e) {
       throw new Error(`Failed to delete object (key=${key}): ${(e as Error).message}`);
     }
-  }
+  };
 }
 
 export const clientS3Storage = new BrowserS3Storage();

package/src/services/file/client.ts

@@ -2,7 +2,6 @@ import { clientDB } from '@/database/client/db';
 import { FileModel } from '@/database/server/models/file';
 import { BaseClientService } from '@/services/baseClientService';
 import { clientS3Storage } from '@/services/file/ClientS3';
-import { FileItem, UploadFileParams } from '@/types/files';
 
 import { IFileService } from './type';
 
@@ -11,7 +10,7 @@ export class ClientService extends BaseClientService implements IFileService {
     return new FileModel(clientDB as any, this.userId);
   }
 
-  async createFile(file: UploadFileParams) {
+  createFile: IFileService['createFile'] = async (file) => {
     // save to local storage
     // we may want to save to a remote server later
     const res = await this.fileModel.create(
@@ -34,9 +33,9 @@ export class ClientService extends BaseClientService implements IFileService {
       id: res.id,
       url: `data:${file.fileType};base64,${base64}`,
     };
-  }
+  };
 
-  async getFile(id: string): Promise<FileItem> {
+  getFile: IFileService['getFile'] = async (id) => {
     const item = await this.fileModel.findById(id);
     if (!item) {
       throw new Error('file not found');
@@ -57,28 +56,28 @@ export class ClientService extends BaseClientService implements IFileService {
       updatedAt: new Date(item.updatedAt),
       url,
     };
-  }
+  };
 
-  async removeFile(id: string) {
+  removeFile: IFileService['removeFile'] = async (id) => {
     await this.fileModel.delete(id, false);
-  }
+  };
 
-  async removeFiles(ids: string[]) {
+  removeFiles: IFileService['removeFiles'] = async (ids) => {
     await this.fileModel.deleteMany(ids, false);
-  }
+  };
 
-  async removeAllFiles() {
+  removeAllFiles: IFileService['removeAllFiles'] = async () => {
     return this.fileModel.clear();
-  }
+  };
 
-  async checkFileHash(hash: string) {
+  checkFileHash: IFileService['checkFileHash'] = async (hash) => {
     return this.fileModel.checkHash(hash);
-  }
+  };
 
-  private async getBase64ByFileHash(hash: string) {
+  private getBase64ByFileHash = async (hash: string) => {
     const fileItem = await clientS3Storage.getObject(hash);
     if (!fileItem) throw new Error('file not found');
 
     return Buffer.from(await fileItem.arrayBuffer()).toString('base64');
-  }
+  };
 }

package/src/services/file/server.ts

@@ -1,10 +1,5 @@
 import { lambdaClient } from '@/libs/trpc/client';
-import {
-  FileItem,
-  QueryFileListParams,
-  QueryFileListSchemaType,
-  UploadFileParams,
-} from '@/types/files';
+import { QueryFileListParams, QueryFileListSchemaType, UploadFileParams } from '@/types/files';
 
 import { IFileService } from './type';
 
@@ -14,11 +9,11 @@ interface CreateFileParams extends Omit<UploadFileParams, 'url'> {
 }
 
 export class ServerService implements IFileService {
-  async createFile(params: UploadFileParams, knowledgeBaseId?: string) {
+  createFile: IFileService['createFile'] = async (params, knowledgeBaseId) => {
     return lambdaClient.file.createFile.mutate({ ...params, knowledgeBaseId } as CreateFileParams);
-  }
+  };
 
-  async getFile(id: string): Promise<FileItem> {
+  getFile: IFileService['getFile'] = async (id) => {
     const item = await lambdaClient.file.findById.query({ id });
 
     if (!item) {
@@ -26,33 +21,33 @@ export class ServerService implements IFileService {
     }
 
     return { ...item, type: item.fileType };
-  }
+  };
 
-  async removeFile(id: string) {
+  removeFile: IFileService['removeFile'] = async (id) => {
     await lambdaClient.file.removeFile.mutate({ id });
-  }
+  };
 
-  async removeFiles(ids: string[]) {
+  removeFiles: IFileService['removeFiles'] = async (ids) => {
     await lambdaClient.file.removeFiles.mutate({ ids });
-  }
+  };
 
-  async removeAllFiles() {
+  removeAllFiles: IFileService['removeAllFiles'] = async () => {
     await lambdaClient.file.removeAllFiles.mutate();
-  }
+  };
 
-  async getFiles(params: QueryFileListParams) {
+  getFiles = async (params: QueryFileListParams) => {
     return lambdaClient.file.getFiles.query(params as QueryFileListSchemaType);
-  }
+  };
 
-  async getFileItem(id: string) {
+  getFileItem = async (id: string) => {
     return lambdaClient.file.getFileItemById.query({ id });
-  }
+  };
 
-  async checkFileHash(hash: string) {
+  checkFileHash: IFileService['checkFileHash'] = async (hash) => {
     return lambdaClient.file.checkFileHash.mutate({ hash });
-  }
+  };
 
-  async removeFileAsyncTask(id: string, type: 'embedding' | 'chunk') {
-    return await lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
-  }
+  removeFileAsyncTask = async (id: string, type: 'embedding' | 'chunk') => {
+    return lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
+  };
 }

package/src/services/global.ts

@@ -4,7 +4,7 @@ import { edgeClient } from '@/libs/trpc/client';
 import { LobeAgentConfig } from '@/types/agent';
 import { GlobalServerConfig } from '@/types/serverConfig';
 
-const VERSION_URL = 'https://registry.npmmirror.com/@lobehub/chat';
+const VERSION_URL = 'https://registry.npmmirror.com/@lobehub/chat/latest';
 
 class GlobalService {
   /**
@@ -14,7 +14,7 @@ class GlobalService {
     const res = await fetch(VERSION_URL);
     const data = await res.json();
 
-    return data['dist-tags']?.latest;
+    return data['version'];
   };
 
   getGlobalConfig = async (): Promise<GlobalServerConfig> => {

package/src/services/import/client.ts

@@ -2,19 +2,20 @@ import { clientDB } from '@/database/client/db';
 import { DataImporterRepos } from '@/database/repositories/dataImporter';
 import { BaseClientService } from '@/services/baseClientService';
 import { useUserStore } from '@/store/user';
-import { ImportStage, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
-import { UserSettings } from '@/types/user/settings';
+import { ImportStage } from '@/types/importer';
 
-export class ClientService extends BaseClientService {
+import { IImportService } from './type';
+
+export class ClientService extends BaseClientService implements IImportService {
   private get dataImporter(): DataImporterRepos {
     return new DataImporterRepos(clientDB as any, this.userId);
   }
 
-  importSettings = async (settings: UserSettings) => {
+  importSettings: IImportService['importSettings'] = async (settings) => {
     await useUserStore.getState().importAppSettings(settings);
   };
 
-  importData = async (data: ImporterEntryData, callbacks?: OnImportCallbacks) => {
+  importData: IImportService['importData'] = async (data, callbacks) => {
     callbacks?.onStageChange?.(ImportStage.Importing);
     const time = Date.now();
     try {

package/src/services/import/server.ts

@@ -2,16 +2,17 @@ import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
 
 import { edgeClient, lambdaClient } from '@/libs/trpc/client';
 import { useUserStore } from '@/store/user';
-import { ImportStage, ImporterEntryData, OnImportCallbacks } from '@/types/importer';
-import { UserSettings } from '@/types/user/settings';
+import { ImportStage, OnImportCallbacks } from '@/types/importer';
 import { uuid } from '@/utils/uuid';
 
-export class ServerService {
-  importSettings = async (settings: UserSettings) => {
+import { IImportService } from './type';
+
+export class ServerService implements IImportService {
+  importSettings: IImportService['importSettings'] = async (settings) => {
     await useUserStore.getState().importAppSettings(settings);
   };
 
-  importData = async (data: ImporterEntryData, callbacks?: OnImportCallbacks): Promise<void> => {
+  importData: IImportService['importData'] = async (data, callbacks) => {
     const handleError = (e: unknown) => {
       callbacks?.onStageChange?.(ImportStage.Error);
       const error = e as DefaultErrorShape;

package/src/services/import/type.ts

@@ -0,0 +1,7 @@
+import { ImporterEntryData, OnImportCallbacks } from '@/types/importer';
+import { UserSettings } from '@/types/user/settings';
+
+export interface IImportService {
+  importData(data: ImporterEntryData, callbacks?: OnImportCallbacks): Promise<void>;
+  importSettings(settings: UserSettings): Promise<void>;
+}