@lobehub/chat 1.82.10 → 1.83.0

package/apps/desktop/src/main/utils/next-electron-rsc.ts

@@ -0,0 +1,383 @@
+// copy from https://github.com/kirill-konshin/next-electron-rsc
+import { serialize as serializeCookie } from 'cookie';
+import type { Protocol, Session } from 'electron';
+import type { NextConfig } from 'next';
+import type NextNodeServer from 'next/dist/server/next-server';
+import assert from 'node:assert';
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { Socket } from 'node:net';
+import path from 'node:path';
+import { parse } from 'node:url';
+import resolve from 'resolve';
+import { parse as parseCookie, splitCookiesString } from 'set-cookie-parser';
+
+import { isDev } from '@/const/env';
+import { createLogger } from '@/utils/logger';
+
+// 创建日志记录器
+const logger = createLogger('utils:next-electron-rsc');
+
+// 定义自定义处理器类型
+export type CustomRequestHandler = (request: Request) => Promise<Response | null | undefined>;
+
+export const createRequest = async ({
+  socket,
+  request,
+  session,
+}: {
+  request: Request;
+  session: Session;
+  socket: Socket;
+}): Promise<IncomingMessage> => {
+  const req = new IncomingMessage(socket);
+
+  const url = new URL(request.url);
+
+  // Normal Next.js URL does not contain schema and host/port, otherwise endless loops due to butchering of schema by normalizeRepeatedSlashes in resolve-routes
+  req.url = url.pathname + (url.search || '');
+  req.method = request.method;
+
+  request.headers.forEach((value, key) => {
+    req.headers[key] = value;
+  });
+
+  try {
+    // @see https://github.com/electron/electron/issues/39525#issue-1852825052
+    const cookies = await session.cookies.get({
+      url: request.url,
+      // domain: url.hostname,
+      // path: url.pathname,
+      // `secure: true` Cookies should not be sent via http
+      // secure: url.protocol === 'http:' ? false : undefined,
+      // theoretically not possible to implement sameSite because we don't know the url
+      // of the website that is requesting the resource
+    });
+
+    if (cookies.length) {
+      const cookiesHeader = [];
+
+      for (const cookie of cookies) {
+        const { name, value } = cookie;
+        cookiesHeader.push(serializeCookie(name, value)); // ...(options as any)?
+      }
+
+      req.headers.cookie = cookiesHeader.join('; ');
+    }
+  } catch (e) {
+    throw new Error('Failed to parse cookies', { cause: e });
+  }
+
+  if (request.body) {
+    req.push(Buffer.from(await request.arrayBuffer()));
+  }
+
+  req.push(null);
+  req.complete = true;
+
+  return req;
+};
+
+export class ReadableServerResponse extends ServerResponse {
+  private responsePromise: Promise<Response>;
+
+  constructor(req: IncomingMessage) {
+    super(req);
+
+    this.responsePromise = new Promise<Response>((resolve) => {
+      const readableStream = new ReadableStream({
+        cancel: () => {},
+        pull: () => {
+          this.emit('drain');
+        },
+        start: (controller) => {
+          let onData;
+
+          this.on(
+            'data',
+            (onData = (chunk) => {
+              controller.enqueue(chunk);
+            }),
+          );
+
+          this.once('end', (chunk) => {
+            controller.enqueue(chunk);
+            controller.close();
+            this.off('data', onData);
+          });
+        },
+      });
+
+      this.once('writeHead', (statusCode) => {
+        resolve(
+          new Response(readableStream, {
+            headers: this.getHeaders() as any,
+            status: statusCode,
+            statusText: this.statusMessage,
+          }),
+        );
+      });
+    });
+  }
+
+  write(chunk: any, ...args): boolean {
+    this.emit('data', chunk);
+    return super.write(chunk, ...args);
+  }
+
+  end(chunk: any, ...args): this {
+    this.emit('end', chunk);
+    return super.end(chunk, ...args);
+  }
+
+  writeHead(statusCode: number, ...args: any): this {
+    this.emit('writeHead', statusCode);
+    return super.writeHead(statusCode, ...args);
+  }
+
+  getResponse() {
+    return this.responsePromise;
+  }
+}
+
+/**
+ * https://nextjs.org/docs/pages/building-your-application/configuring/custom-server
+ * https://github.com/vercel/next.js/pull/68167/files#diff-d0d8b7158bcb066cdbbeb548a29909fe8dc4e98f682a6d88654b1684e523edac
+ * https://github.com/vercel/next.js/blob/canary/examples/custom-server/server.ts
+ *
+ * @param {string} standaloneDir
+ * @param {string} localhostUrl
+ * @param {import('electron').Protocol} protocol
+ * @param {boolean} debug
+ */
+export function createHandler({
+  standaloneDir,
+  localhostUrl,
+  protocol,
+  debug = false,
+}: {
+  debug?: boolean;
+  localhostUrl: string;
+  protocol: Protocol;
+  standaloneDir: string;
+}) {
+  assert(standaloneDir, 'standaloneDir is required');
+  assert(protocol, 'protocol is required');
+
+  // 存储自定义请求处理器的数组
+  const customHandlers: CustomRequestHandler[] = [];
+
+  // 注册自定义请求处理器的方法 - 在开发和生产环境中都提供此功能
+  function registerCustomHandler(handler: CustomRequestHandler) {
+    logger.debug('Registering custom request handler');
+    customHandlers.push(handler);
+    return () => {
+      const index = customHandlers.indexOf(handler);
+      if (index !== -1) {
+        logger.debug('Unregistering custom request handler');
+        customHandlers.splice(index, 1);
+      }
+    };
+  }
+  let registerProtocolHandle = false;
+
+  protocol.registerSchemesAsPrivileged([
+    {
+      privileges: {
+        secure: true,
+        standard: true,
+        supportFetchAPI: true,
+      },
+      scheme: 'http',
+    },
+  ]);
+  logger.debug('Registered HTTP scheme as privileged');
+
+  // 初始化 Next.js 应用（仅在生产环境中使用）
+  let app: NextNodeServer | null = null;
+  let handler: any = null;
+  let preparePromise: Promise<void> | null = null;
+
+  if (!isDev) {
+    logger.info('Initializing Next.js app for production');
+    const next = require(resolve.sync('next', { basedir: standaloneDir }));
+
+    // @see https://github.com/vercel/next.js/issues/64031#issuecomment-2078708340
+    const config = require(path.join(standaloneDir, '.next', 'required-server-files.json'))
+      .config as NextConfig;
+    process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
+
+    app = next({
+      dev: false,
+      dir: standaloneDir,
+    }) as NextNodeServer;
+
+    handler = app.getRequestHandler();
+    preparePromise = app.prepare();
+  } else {
+    logger.debug('Starting in development mode');
+  }
+
+  // 通用的请求处理函数 - 开发和生产环境共用
+  const handleRequest = async (
+    request: Request,
+    session: Session,
+    socket: Socket,
+  ): Promise<Response> => {
+    try {
+      // 先尝试使用自定义处理器处理请求
+      for (const customHandler of customHandlers) {
+        try {
+          const response = await customHandler(request);
+          if (response) {
+            if (debug) logger.debug(`Custom handler processed: ${request.url}`);
+            return response;
+          }
+        } catch (error) {
+          if (debug) logger.error(`Custom handler error: ${error}`);
+          // 继续尝试下一个处理器
+        }
+      }
+
+      // 创建 Node.js 请求对象
+      const req = await createRequest({ request, session, socket });
+      // 创建可读取响应的 Response 对象
+      const res = new ReadableServerResponse(req);
+
+      if (isDev) {
+        // 开发环境：转发请求到开发服务器
+        if (debug) logger.debug(`Forwarding request to dev server: ${request.url}`);
+
+        // 修改 URL 以指向开发服务器
+        const devUrl = new URL(req.url, localhostUrl);
+
+        // 使用 node:http 模块发送请求到开发服务器
+        const http = require('node:http');
+        const devReq = http.request(
+          {
+            headers: req.headers,
+            hostname: devUrl.hostname,
+            method: req.method,
+            path: devUrl.pathname + (devUrl.search || ''),
+            port: devUrl.port,
+          },
+          (devRes) => {
+            // 设置响应状态码和头部
+            res.statusCode = devRes.statusCode;
+            res.statusMessage = devRes.statusMessage;
+
+            // 复制响应头
+            Object.keys(devRes.headers).forEach((key) => {
+              res.setHeader(key, devRes.headers[key]);
+            });
+
+            // 流式传输响应内容
+            devRes.pipe(res);
+          },
+        );
+
+        // 处理错误
+        devReq.on('error', (err) => {
+          if (debug) logger.error(`Error forwarding request: ${err}`);
+        });
+
+        // 传输请求体
+        req.pipe(devReq);
+      } else {
+        // 生产环境：使用 Next.js 处理请求
+        if (debug) logger.debug(`Processing with Next.js handler: ${request.url}`);
+
+        // 确保 Next.js 已准备就绪
+        if (preparePromise) await preparePromise;
+
+        const url = parse(req.url, true);
+        handler(req, res, url);
+      }
+
+      // 获取 Response 对象
+      const response = await res.getResponse();
+
+      // 处理 cookies（两种环境通用处理）
+      try {
+        const cookies = parseCookie(
+          response.headers.getSetCookie().reduce((r, c) => {
+            return [...r, ...splitCookiesString(c)];
+          }, []),
+        );
+
+        for (const cookie of cookies) {
+          const expires = cookie.expires
+            ? cookie.expires.getTime()
+            : cookie.maxAge
+              ? Date.now() + cookie.maxAge * 1000
+              : undefined;
+
+          if (expires && expires < Date.now()) {
+            await session.cookies.remove(request.url, cookie.name);
+            continue;
+          }
+
+          await session.cookies.set({
+            domain: cookie.domain,
+            expirationDate: expires,
+            httpOnly: cookie.httpOnly,
+            name: cookie.name,
+            path: cookie.path,
+            secure: cookie.secure,
+            url: request.url,
+            value: cookie.value,
+          } as any);
+        }
+      } catch (e) {
+        logger.error('Failed to set cookies', e);
+      }
+
+      if (debug) logger.debug(`Request processed: ${request.url}, status: ${response.status}`);
+      return response;
+    } catch (e) {
+      if (debug) logger.error(`Error handling request: ${e}`);
+      return new Response(e.message, { status: 500 });
+    }
+  };
+
+  // 创建拦截器函数
+  const createInterceptor = ({ session }: { session: Session }) => {
+    assert(session, 'Session is required');
+    logger.debug(
+      `Creating interceptor with session in ${isDev ? 'development' : 'production'} mode`,
+    );
+
+    const socket = new Socket();
+
+    const closeSocket = () => socket.end();
+
+    process.on('SIGTERM', () => closeSocket);
+    process.on('SIGINT', () => closeSocket);
+
+    if (!isDev && !registerProtocolHandle) {
+      logger.debug(
+        `Registering HTTP protocol handler in ${isDev ? 'development' : 'production'} mode`,
+      );
+      protocol.handle('http', async (request) => {
+        if (!isDev) {
+          assert(request.url.startsWith(localhostUrl), 'External HTTP not supported, use HTTPS');
+        }
+
+        return handleRequest(request, session, socket);
+      });
+      registerProtocolHandle = true;
+    }
+
+    return function stopIntercept() {
+      if (registerProtocolHandle) {
+        logger.debug('Unregistering HTTP protocol handler');
+        protocol.unhandle('http');
+        registerProtocolHandle = false;
+      }
+      process.off('SIGTERM', () => closeSocket);
+      process.off('SIGINT', () => closeSocket);
+      closeSocket();
+    };
+  };
+
+  return { createInterceptor, registerCustomHandler };
+}

package/apps/desktop/src/preload/electronApi.ts

@@ -0,0 +1,18 @@
+import { electronAPI } from '@electron-toolkit/preload';
+import { contextBridge } from 'electron';
+
+import { invoke } from './invoke';
+
+export const setupElectronApi = () => {
+  // Use `contextBridge` APIs to expose Electron APIs to
+  // renderer only if context isolation is enabled, otherwise
+  // just add to the DOM global.
+
+  try {
+    contextBridge.exposeInMainWorld('electron', electronAPI);
+  } catch (error) {
+    console.error(error);
+  }
+
+  contextBridge.exposeInMainWorld('electronAPI', { invoke });
+};

package/apps/desktop/src/preload/index.ts

@@ -0,0 +1,14 @@
+import { setupElectronApi } from './electronApi';
+import { setupRouteInterceptors } from './routeInterceptor';
+
+const setupPreload = () => {
+  setupElectronApi();
+
+  // 设置路由拦截逻辑
+  window.addEventListener('DOMContentLoaded', () => {
+    // 设置客户端路由拦截器
+    setupRouteInterceptors();
+  });
+};
+
+setupPreload();

package/apps/desktop/src/preload/invoke.ts

@@ -0,0 +1,10 @@
+import { ClientDispatchEventKey, DispatchInvoke } from '@lobechat/electron-client-ipc';
+import { ipcRenderer } from 'electron';
+
+/**
+ * client 端请求 electron main 端方法
+ */
+export const invoke: DispatchInvoke = async <T extends ClientDispatchEventKey>(
+  event: T,
+  ...data: any[]
+) => ipcRenderer.invoke(event, ...data);

package/apps/desktop/src/preload/routeInterceptor.ts

@@ -0,0 +1,162 @@
+import { findMatchingRoute } from '~common/routes';
+
+import { invoke } from './invoke';
+
+const interceptRoute = async (
+  path: string,
+  source: 'link-click' | 'push-state' | 'replace-state',
+  url: string,
+) => {
+  console.log(`[preload] Intercepted ${source} and prevented default behavior:`, path);
+
+  // 使用electron-client-ipc的dispatch方法
+  try {
+    await invoke('interceptRoute', { path, source, url });
+  } catch (e) {
+    console.error(`[preload] Route interception (${source}) call failed`, e);
+  }
+};
+/**
+ * 路由拦截器 - 负责捕获和拦截客户端路由导航
+ */
+export const setupRouteInterceptors = function () {
+  console.log('[preload] Setting up route interceptors');
+
+  // 存储被阻止的路径，避免pushState重复触发
+  const preventedPaths = new Set<string>();
+
+  // 拦截所有a标签的点击事件 - 针对Next.js的Link组件
+  document.addEventListener(
+    'click',
+    async (e) => {
+      const link = (e.target as HTMLElement).closest('a');
+      if (link && link.href) {
+        try {
+          const url = new URL(link.href);
+
+          // 使用共享配置检查是否需要拦截
+          const matchedRoute = findMatchingRoute(url.pathname);
+
+          // 如果是需要拦截的路径，立即阻止默认行为
+          if (matchedRoute) {
+            // 检查当前页面是否已经在目标路径下，如果是则不拦截
+            const currentPath = window.location.pathname;
+            const isAlreadyInTargetPage = currentPath.startsWith(matchedRoute.pathPrefix);
+
+            // 如果已经在目标页面下，则不拦截，让默认导航继续
+            if (isAlreadyInTargetPage) return;
+
+            // 立即阻止默认行为，避免Next.js接管路由
+            e.preventDefault();
+            e.stopPropagation();
+
+            await interceptRoute(url.pathname, 'link-click', link.href);
+
+            return false;
+          }
+        } catch (err) {
+          console.error('[preload] Link interception error:', err);
+        }
+      }
+    },
+    true,
+  );
+
+  // 拦截 history API (用于捕获Next.js的useRouter().push/replace等)
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+
+  // 重写pushState
+  history.pushState = function () {
+    const url = arguments[2];
+    if (typeof url === 'string') {
+      try {
+        // 只处理相对路径或当前域的URL
+        const parsedUrl = new URL(url, window.location.origin);
+
+        // 使用共享配置检查是否需要拦截
+        const matchedRoute = findMatchingRoute(parsedUrl.pathname);
+
+        // 检查是否需要拦截这个导航
+        if (matchedRoute) {
+          // 检查当前页面是否已经在目标路径下，如果是则不拦截
+          const currentPath = window.location.pathname;
+          const isAlreadyInTargetPage = currentPath.startsWith(matchedRoute.pathPrefix);
+
+          // 如果已经在目标页面下，则不拦截，让默认导航继续
+          if (isAlreadyInTargetPage) {
+            console.log(
+              `[preload] Skip pushState interception for ${parsedUrl.pathname} because already in target page ${matchedRoute.pathPrefix}`,
+            );
+            return Reflect.apply(originalPushState, this, arguments);
+          }
+
+          // 将此路径添加到已阻止集合中
+          preventedPaths.add(parsedUrl.pathname);
+
+          interceptRoute(parsedUrl.pathname, 'push-state', parsedUrl.href);
+
+          // 不执行原始的pushState操作，阻止导航发生
+          // 但返回undefined以避免错误
+          return;
+        }
+      } catch (err) {
+        console.error('[preload] pushState interception error:', err);
+      }
+    }
+    return Reflect.apply(originalPushState, this, arguments);
+  };
+
+  // 重写replaceState
+  history.replaceState = function () {
+    const url = arguments[2];
+    if (typeof url === 'string') {
+      try {
+        const parsedUrl = new URL(url, window.location.origin);
+
+        // 使用共享配置检查是否需要拦截
+        const matchedRoute = findMatchingRoute(parsedUrl.pathname);
+
+        // 检查是否需要拦截这个导航
+        if (matchedRoute) {
+          // 检查当前页面是否已经在目标路径下，如果是则不拦截
+          const currentPath = window.location.pathname;
+          const isAlreadyInTargetPage = currentPath.startsWith(matchedRoute.pathPrefix);
+
+          // 如果已经在目标页面下，则不拦截，让默认导航继续
+          if (isAlreadyInTargetPage) {
+            console.log(
+              `[preload] Skip replaceState interception for ${parsedUrl.pathname} because already in target page ${matchedRoute.pathPrefix}`,
+            );
+            return Reflect.apply(originalReplaceState, this, arguments);
+          }
+
+          // 添加到已阻止集合
+          preventedPaths.add(parsedUrl.pathname);
+
+          interceptRoute(parsedUrl.pathname, 'replace-state', parsedUrl.href);
+
+          // 阻止导航
+          return;
+        }
+      } catch (err) {
+        console.error('[preload] replaceState interception error:', err);
+      }
+    }
+    return Reflect.apply(originalReplaceState, this, arguments);
+  };
+
+  // 监听并拦截路由错误 - 有时Next.js会在路由错误时尝试恢复导航
+  window.addEventListener(
+    'error',
+    function (e) {
+      if (e.message && e.message.includes('navigation') && preventedPaths.size > 0) {
+        console.log('[preload] Captured possible routing error, preventing default behavior');
+        e.preventDefault();
+      }
+    },
+    true,
+  );
+
+  console.log('[preload] Route interceptors setup completed');
+};

package/apps/desktop/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "target": "ESNext",
+    "esModuleInterop": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/main/*"],
+      "~common/*": ["src/common/*"]
+    }
+  },
+  "include": ["src/main/**/*", "src/preload/**/*", "electron-builder.js"]
+}

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "features": [
+        "Support desktop release framework and workflow."
+      ]
+    },
+    "date": "2025-04-27",
+    "version": "1.83.0"
+  },
   {
     "children": {
       "improvements": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.82.10",
+  "version": "1.83.0",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/electron-client-ipc/src/events/remoteServer.ts

@@ -1,20 +1,27 @@
-import { RemoteServerConfig } from '../types/remoteServer';
+import { DataSyncConfig } from '../types/dataSync';
+import { ProxyTRPCRequestParams, ProxyTRPCRequestResult } from '../types/proxyTRPCRequest';
 
 /**
  * 远程服务器配置相关的事件
  */
 export interface RemoteServerDispatchEvents {
   clearRemoteServerConfig: () => boolean;
-  getRemoteServerConfig: () => RemoteServerConfig;
+  getRemoteServerConfig: () => DataSyncConfig;
+  /**
+   * Proxy a tRPC request to the remote server.
+   * @param args - Request arguments.
+   * @returns Promise resolving with the response details.
+   */
+  proxyTRPCRequest: (args: ProxyTRPCRequestParams) => ProxyTRPCRequestResult;
   refreshAccessToken: () => {
     error?: string;
     success: boolean;
   };
-  requestAuthorization: (serverUrl: string) => {
+  requestAuthorization: (config: DataSyncConfig) => {
     error?: string;
     success: boolean;
   };
-  setRemoteServerConfig: (config: RemoteServerConfig) => boolean;
+  setRemoteServerConfig: (config: DataSyncConfig) => boolean;
 }
 
 /**

package/packages/electron-client-ipc/src/types/dataSync.ts

@@ -0,0 +1,15 @@
+export type StorageMode = 'local' | 'cloud' | 'selfHost';
+export enum StorageModeEnum {
+  Cloud = 'cloud',
+  Local = 'local',
+  SelfHost = 'selfHost',
+}
+
+/**
+ * 远程服务器配置相关的事件
+ */
+export interface DataSyncConfig {
+  active?: boolean;
+  remoteServerUrl?: string;
+  storageMode: StorageMode;
+}

package/packages/electron-client-ipc/src/types/index.ts

@@ -1,6 +1,7 @@
+export * from './dataSync';
 export * from './dispatch';
 export * from './localFile';
-export * from './remoteServer';
+export * from './proxyTRPCRequest';
 export * from './route';
 export * from './shortcut';
 export * from './system';