@lobehub/chat 1.82.10 → 1.83.1

package/src/database/core/electron.ts

@@ -0,0 +1,317 @@
+import { PGlite } from '@electric-sql/pglite';
+import { vector } from '@electric-sql/pglite/vector';
+import { drizzle as pgliteDrizzle } from 'drizzle-orm/pglite';
+import fs from 'node:fs';
+import { Md5 } from 'ts-md5';
+
+import { DrizzleMigrationModel } from '@/database/models/drizzleMigration';
+import * as schema from '@/database/schemas';
+import { electronIpcClient } from '@/server/modules/ElectronIPCClient';
+import { MigrationTableItem } from '@/types/clientDB';
+
+import migrations from '../client/migrations.json';
+import { LobeChatDatabase } from '../type';
+
+// 用于实例管理的全局对象
+interface LobeGlobal {
+  pgDB?: LobeChatDatabase;
+  pgDBInitPromise?: Promise<LobeChatDatabase>;
+  pgDBLock?: {
+    acquired: boolean;
+    lockPath: string;
+  };
+}
+
+// 确保 globalThis 有我们的命名空间
+declare global {
+  // eslint-disable-next-line no-var
+  var __LOBE__: LobeGlobal;
+}
+
+if (!globalThis.__LOBE__) {
+  globalThis.__LOBE__ = {};
+}
+
+/**
+ * 尝试创建一个文件锁来确保单例模式
+ * 返回 true 表示成功获取锁，false 表示已有其他实例正在运行
+ */
+const acquireLock = async (dbPath: string): Promise<boolean> => {
+  try {
+    // 数据库锁文件路径
+    const lockPath = `${dbPath}.lock`;
+
+    // 尝试创建锁文件
+    if (!fs.existsSync(lockPath)) {
+      // 创建锁文件并写入当前进程 ID
+      fs.writeFileSync(lockPath, process.pid.toString(), 'utf8');
+
+      // 保存锁信息到全局对象
+      if (!globalThis.__LOBE__.pgDBLock) {
+        globalThis.__LOBE__.pgDBLock = {
+          acquired: true,
+          lockPath,
+        };
+      }
+
+      console.log(`✅ Successfully acquired database lock: ${lockPath}`);
+      return true;
+    }
+
+    // 检查锁文件是否过期（超过5分钟未更新）
+    const stats = fs.statSync(lockPath);
+    const currentTime = Date.now();
+    const modifiedTime = stats.mtime.getTime();
+
+    // 如果锁文件超过5分钟未更新，视为过期锁
+    if (currentTime - modifiedTime > 5 * 60 * 1000) {
+      // 删除过期锁文件
+      fs.unlinkSync(lockPath);
+      // 重新创建锁文件
+      fs.writeFileSync(lockPath, process.pid.toString(), 'utf8');
+
+      // 保存锁信息到全局对象
+      if (!globalThis.__LOBE__.pgDBLock) {
+        globalThis.__LOBE__.pgDBLock = {
+          acquired: true,
+          lockPath,
+        };
+      }
+
+      console.log(`✅ Removed stale lock and acquired new lock: ${lockPath}`);
+      return true;
+    }
+
+    console.warn(`⚠️ Another process has already locked the database: ${lockPath}`);
+    return false;
+  } catch (error) {
+    console.error('❌ Failed to acquire database lock:', error);
+    return false;
+  }
+};
+
+/**
+ * 释放文件锁
+ */
+const releaseLock = () => {
+  if (globalThis.__LOBE__.pgDBLock?.acquired && globalThis.__LOBE__.pgDBLock.lockPath) {
+    try {
+      fs.unlinkSync(globalThis.__LOBE__.pgDBLock.lockPath);
+      globalThis.__LOBE__.pgDBLock.acquired = false;
+      console.log(`✅ Released database lock: ${globalThis.__LOBE__.pgDBLock.lockPath}`);
+    } catch (error) {
+      console.error('❌ Failed to release database lock:', error);
+    }
+  }
+};
+
+// 在进程退出时释放锁
+process.on('exit', releaseLock);
+process.on('SIGINT', () => {
+  releaseLock();
+  process.exit(0);
+});
+
+process.on('uncaughtException', (error) => {
+  // ignore ECONNRESET error
+  if ((error as any).code === 'ECONNRESET') return;
+
+  console.error('Uncaught exception:', error);
+  releaseLock();
+});
+
+const migrateDatabase = async (db: LobeChatDatabase): Promise<void> => {
+  try {
+    let hash: string | undefined;
+    const cacheHash = await electronIpcClient.getDatabaseSchemaHash();
+
+    hash = Md5.hashStr(JSON.stringify(migrations));
+
+    console.log('schemaHash:', hash);
+
+    // 如果哈希值相同，看下表是否全了
+    if (hash === cacheHash) {
+      try {
+        const drizzleMigration = new DrizzleMigrationModel(db);
+
+        // 检查数据库中是否存在表
+        const tableCount = await drizzleMigration.getTableCounts();
+
+        // 如果表数量大于0，则认为数据库已正确初始化
+        if (tableCount > 0) {
+          console.log('✅ Electron DB schema already synced');
+          return;
+        }
+      } catch (error) {
+        console.warn('Error checking table existence, proceeding with migration:');
+        console.warn(error);
+      }
+    }
+
+    const start = Date.now();
+    console.log('🚀 Starting Electron DB migration...');
+
+    try {
+      // 执行迁移
+      // @ts-expect-error
+      await db.dialect.migrate(migrations, db.session, {});
+
+      await electronIpcClient.setDatabaseSchemaHash(hash);
+
+      console.info(`✅ Electron DB migration success, took ${Date.now() - start}ms`);
+    } catch (error) {
+      console.error('❌ Electron database schema migration failed', error);
+
+      // 尝试查询迁移表数据
+      let migrationsTableData: MigrationTableItem[] = [];
+      try {
+        // 尝试查询迁移表
+        const drizzleMigration = new DrizzleMigrationModel(db);
+        migrationsTableData = await drizzleMigration.getMigrationList();
+      } catch (queryError) {
+        console.error('Failed to query migrations table:', queryError);
+      }
+
+      throw {
+        error: error as Error,
+        migrationTableItems: migrationsTableData,
+      };
+    }
+  } catch (error) {
+    console.error('❌ Electron database migration failed:', error);
+    throw error;
+  }
+};
+
+/**
+ * 检查当前是否有活跃的数据库实例，如果有则尝试关闭它
+ */
+const checkAndCleanupExistingInstance = async () => {
+  if (globalThis.__LOBE__.pgDB) {
+    try {
+      // 尝试关闭现有的 PGlite 实例 (如果客户端有 close 方法)
+      // @ts-expect-error
+      const client = globalThis.__LOBE__.pgDB?.dialect?.client;
+
+      if (client && typeof client.close === 'function') {
+        await client.close();
+        console.log('✅ Successfully closed previous PGlite instance');
+      }
+
+      // 重置全局引用
+      globalThis.__LOBE__.pgDB = undefined;
+    } catch (error) {
+      console.error('❌ Failed to close previous PGlite instance:', error);
+      // 继续执行，创建新实例
+    }
+  }
+};
+
+let isInitializing = false;
+
+export const getPgliteInstance = async (): Promise<LobeChatDatabase> => {
+  try {
+    console.log(
+      'Getting PGlite instance, state:',
+      JSON.stringify({
+        hasExistingDB: !!globalThis.__LOBE__.pgDB,
+        hasPromise: !!globalThis.__LOBE__.pgDBInitPromise,
+        isInitializing,
+      }),
+    );
+
+    // 已经初始化完成，直接返回实例
+    if (globalThis.__LOBE__.pgDB) return globalThis.__LOBE__.pgDB;
+
+    // 有初始化进行中的Promise，等待它完成
+    if (globalThis.__LOBE__.pgDBInitPromise) {
+      console.log('Waiting for existing initialization promise to complete');
+      return globalThis.__LOBE__.pgDBInitPromise;
+    }
+
+    // 防止多次调用引起的竞态条件
+    if (isInitializing) {
+      console.log('Already initializing, waiting for result');
+      // 创建新的 Promise 等待初始化完成
+      return new Promise((resolve, reject) => {
+        const checkInterval = setInterval(() => {
+          if (globalThis.__LOBE__.pgDB) {
+            clearInterval(checkInterval);
+            resolve(globalThis.__LOBE__.pgDB);
+          } else if (!isInitializing) {
+            clearInterval(checkInterval);
+            reject(new Error('Initialization failed or was canceled'));
+          }
+        }, 100);
+      });
+    }
+
+    isInitializing = true;
+
+    // 创建初始化Promise并保存
+    globalThis.__LOBE__.pgDBInitPromise = (async () => {
+      // 再次检查，以防在等待过程中已有其他调用初始化成功
+      if (globalThis.__LOBE__.pgDB) return globalThis.__LOBE__.pgDB;
+
+      // 先获取数据库路径
+      let dbPath: string = '';
+      try {
+        dbPath = await electronIpcClient.getDatabasePath();
+      } catch {
+        /* empty */
+      }
+
+      console.log('Database path:', dbPath);
+      try {
+        // 尝试获取数据库锁
+        const lockAcquired = await acquireLock(dbPath);
+        if (!lockAcquired) {
+          throw new Error('Cannot acquire database lock. Another instance might be using it.');
+        }
+
+        // 检查并清理可能存在的旧实例
+        await checkAndCleanupExistingInstance();
+
+        // 创建新的 PGlite 实例
+        console.log('Creating new PGlite instance');
+        const client = new PGlite(dbPath, {
+          extensions: { vector },
+          // 增加选项以提高稳定性
+          relaxedDurability: true,
+        });
+
+        // 等待数据库就绪
+        await client.waitReady;
+        console.log('PGlite state:', client.ready);
+
+        // 创建 Drizzle 数据库实例
+        const db = pgliteDrizzle({ client, schema }) as unknown as LobeChatDatabase;
+
+        // 执行迁移
+        await migrateDatabase(db);
+
+        // 保存实例引用
+        globalThis.__LOBE__.pgDB = db;
+
+        console.log('✅ PGlite instance successfully initialized');
+
+        return db;
+      } catch (error) {
+        console.error('❌ Failed to initialize PGlite instance:', error);
+        // 清空初始化Promise，允许下次重试
+        globalThis.__LOBE__.pgDBInitPromise = undefined;
+        // 释放可能已获取的锁
+        releaseLock();
+        throw error;
+      } finally {
+        isInitializing = false;
+      }
+    })();
+
+    return globalThis.__LOBE__.pgDBInitPromise;
+  } catch (error) {
+    console.error('❌ Unexpected error in getPgliteInstance:', error);
+    isInitializing = false;
+    throw error;
+  }
+};

package/src/{app/[variants]/(main)/_layout/Desktop/ElectronTitlebar/Connection/Mode.tsx → features/ElectronTitlebar/Connection/ConnectionMode.tsx}

@@ -1,3 +1,4 @@
+import { StorageMode, StorageModeEnum } from '@lobechat/electron-client-ipc';
 import { Input } from '@lobehub/ui';
 import { LobeHub } from '@lobehub/ui/brand';
 import { Button } from 'antd';
@@ -8,8 +9,9 @@ import { useTranslation } from 'react-i18next';
 import { Center, Flexbox } from 'react-layout-kit';
 
 import { useElectronStore } from '@/store/electron';
+import { electronSyncSelectors } from '@/store/electron/selectors';
 
-import { AccessOption, Option } from './Option';
+import { Option } from './Option';
 
 const useStyles = createStyles(({ token, css }) => {
   return {
@@ -78,12 +80,15 @@ interface ConnectionModeProps {
 const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) => {
   const { styles } = useStyles();
   const { t } = useTranslation(['electron', 'common']);
-  const [selectedOption, setSelectedOption] = useState<AccessOption>();
-  const [selfHostedUrl, setSelfHostedUrl] = useState('');
   const [urlError, setUrlError] = useState<string | undefined>();
 
   const connect = useElectronStore((s) => s.connectRemoteServer);
   const disconnect = useElectronStore((s) => s.disconnectRemoteServer);
+  const storageMode = useElectronStore(electronSyncSelectors.storageMode);
+  const remoteServerUrl = useElectronStore(electronSyncSelectors.remoteServerUrl);
+
+  const [selectedOption, setSelectedOption] = useState<StorageMode>(storageMode);
+  const [selfHostedUrl, setSelfHostedUrl] = useState(remoteServerUrl);
 
   const validateUrl = useCallback((url: string) => {
     if (!url) {
@@ -100,9 +105,9 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
     }
   }, []);
 
-  const handleSelectOption = (option: AccessOption) => {
+  const handleSelectOption = (option: StorageMode) => {
     setSelectedOption(option);
-    if (option !== 'self-hosted') {
+    if (option !== StorageModeEnum.SelfHost) {
       setUrlError(undefined);
     } else {
       setUrlError(validateUrl(selfHostedUrl));
@@ -110,7 +115,7 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
   };
 
   const handleContinue = async () => {
-    if (selectedOption === 'self-hosted') {
+    if (selectedOption === StorageModeEnum.SelfHost) {
       const error = validateUrl(selfHostedUrl);
       setUrlError(error);
       if (error) {
@@ -118,7 +123,7 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
       }
     }
 
-    if (selectedOption === 'local') {
+    if (selectedOption === StorageModeEnum.Local) {
       await disconnect();
       setIsOpen(false);
       return;
@@ -126,11 +131,8 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
 
     // try to connect
     setWaiting(true);
-    await connect(
-      selectedOption === 'self-hosted'
-        ? { isSelfHosted: true, serverUrl: selfHostedUrl }
-        : { isSelfHosted: false },
-    );
+    console.log('selectedOption:', selectedOption);
+    await connect({ remoteServerUrl: selfHostedUrl, storageMode: selectedOption });
   };
 
   return (
@@ -145,7 +147,7 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
             <div className={styles.groupTitle}>{t('sync.mode.cloudSync')}</div>
             <div
               className={styles.selfHostedText}
-              onClick={() => handleSelectOption('self-hosted')}
+              onClick={() => handleSelectOption(StorageModeEnum.SelfHost)}
             >
               {t('sync.mode.useSelfHosted')}
             </div>
@@ -156,18 +158,18 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
             isSelected={selectedOption === 'cloud'}
             label={t('sync.lobehubCloud.title')}
             onClick={handleSelectOption}
-            value="cloud"
+            value={StorageModeEnum.Cloud}
           />
-          {selectedOption === 'self-hosted' && (
+          {selectedOption === StorageModeEnum.SelfHost && (
             <Option
               description={t('sync.selfHosted.description')}
               icon={Server}
-              isSelected={selectedOption === 'self-hosted'}
+              isSelected={selectedOption === StorageModeEnum.SelfHost}
               label={t('sync.selfHosted.title')}
               onClick={handleSelectOption}
-              value="self-hosted"
+              value={StorageModeEnum.SelfHost}
             >
-              {selectedOption === 'self-hosted' && (
+              {selectedOption === StorageModeEnum.SelfHost && (
                 <>
                   <Input
                     autoFocus
@@ -195,10 +197,10 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
           <Option
             description={t('sync.local.description')}
             icon={ComputerIcon}
-            isSelected={selectedOption === 'local'}
+            isSelected={selectedOption === StorageModeEnum.Local}
             label={t('sync.local.title')}
             onClick={handleSelectOption}
-            value="local"
+            value={StorageModeEnum.Local}
           />
         </Flexbox>
       </Flexbox>
@@ -206,7 +208,8 @@ const ConnectionMode = memo<ConnectionModeProps>(({ setIsOpen, setWaiting }) =>
       <Button
         className={styles.continueButton}
         disabled={
-          !selectedOption || (selectedOption === 'self-hosted' && (!!urlError || !selfHostedUrl))
+          !selectedOption ||
+          (selectedOption === StorageModeEnum.SelfHost && (!!urlError || !selfHostedUrl))
         }
         onClick={handleContinue}
         size="large"

package/src/{app/[variants]/(main)/_layout/Desktop → features}/ElectronTitlebar/Connection/Option.tsx

@@ -1,4 +1,5 @@
 import { CheckCircleFilled } from '@ant-design/icons';
+import { StorageModeEnum } from '@lobechat/electron-client-ipc';
 import { createStyles } from 'antd-style';
 import { ComponentType, ReactNode } from 'react';
 import { Center, Flexbox } from 'react-layout-kit';
@@ -55,17 +56,14 @@ const useStyles = createStyles(({ token, css }) => ({
   `,
 }));
 
-// 定义选项类型
-export type AccessOption = 'cloud' | 'self-hosted' | 'local';
-
 export interface OptionProps {
   children?: ReactNode;
   description: string;
   icon: ComponentType<any>;
   isSelected: boolean;
   label: string;
-  onClick: (value: AccessOption) => void;
-  value: AccessOption; // For self-hosted input
+  onClick: (value: StorageModeEnum) => void;
+  value: StorageModeEnum; // For self-hosted input
 }
 
 export const Option = ({

package/src/{app/[variants]/(main)/_layout/Desktop/ElectronTitlebar/Connection/Sync.tsx → features/ElectronTitlebar/Connection/RemoteStatus.tsx}

@@ -9,17 +9,20 @@ import { electronSyncSelectors } from '@/store/electron/selectors';
 interface SyncProps {
   onClick: () => void;
 }
-const Sync = memo<SyncProps>(({ onClick }) => {
+const RemoteStatus = memo<SyncProps>(({ onClick }) => {
   const { t } = useTranslation('electron');
 
-  const [isIniting, isSyncActive, useRemoteServerConfig] = useElectronStore((s) => [
-    !s.isInitRemoteServerConfig,
-    electronSyncSelectors.isSyncActive(s),
-    s.useRemoteServerConfig,
-  ]);
+  const [isIniting, isSyncActive, useRemoteServerConfig, useRefreshDataWhenActive] =
+    useElectronStore((s) => [
+      !s.isInitRemoteServerConfig,
+      electronSyncSelectors.isSyncActive(s),
+      s.useDataSyncConfig,
+      s.useRefreshDataWhenActive,
+    ]);
 
   // 使用useSWR获取远程服务器配置
   useRemoteServerConfig();
+  useRefreshDataWhenActive(isSyncActive);
 
   return (
     <ActionIcon
@@ -39,4 +42,4 @@ const Sync = memo<SyncProps>(({ onClick }) => {
   );
 });
 
-export default Sync;
+export default RemoteStatus;

package/src/{app/[variants]/(main)/_layout/Desktop → features}/ElectronTitlebar/Connection/index.tsx

@@ -2,8 +2,8 @@ import { Drawer } from 'antd';
 import { createStyles } from 'antd-style';
 import { useState } from 'react';
 
-import Mode from './Mode';
-import Sync from './Sync';
+import ConnectionMode from './ConnectionMode';
+import RemoteStatus from './RemoteStatus';
 import WaitingOAuth from './Waiting';
 
 const useStyles = createStyles(({ css }) => {
@@ -26,7 +26,7 @@ const Connection = () => {
 
   return (
     <>
-      <Sync
+      <RemoteStatus
         onClick={() => {
           setIsOpen(true);
         }}
@@ -47,7 +47,7 @@ const Connection = () => {
         {isWaiting ? (
           <WaitingOAuth setIsOpen={setIsOpen} setWaiting={setWaiting} />
         ) : (
-          <Mode setIsOpen={setIsOpen} setWaiting={setWaiting} />
+          <ConnectionMode setIsOpen={setIsOpen} setWaiting={setWaiting} />
         )}
       </Drawer>
     </>

package/src/{app/[variants]/(main)/_layout/Desktop → features}/ElectronTitlebar/UpdateModal.tsx

@@ -4,6 +4,7 @@ import React, { memo, useState } from 'react';
 import { useTranslation } from 'react-i18next';
 
 import { autoUpdateService } from '@/services/electron/autoUpdate';
+import { formatSpeed } from '@/utils/format';
 
 export const UpdateModal = memo(() => {
   const { t } = useTranslation(['electron', 'common']);
@@ -175,7 +176,7 @@ export const UpdateModal = memo(() => {
           <div style={{ fontSize: 12, marginTop: 8, textAlign: 'center' }}>
             {t('updater.downloadingUpdateDesc', { percent })}
             {progress && progress.bytesPerSecond > 0 && (
-              <span> ({(progress.bytesPerSecond / 1024 / 1024).toFixed(2)} MB/s)</span>
+              <span>{formatSpeed(progress.bytesPerSecond)}</span>
             )}
           </div>
         </div>

package/src/libs/trpc/client/async.ts

@@ -1,11 +1,17 @@
 import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import superjson from 'superjson';
 
+import { isDesktop } from '@/const/version';
 import { AsyncRouter } from '@/server/routers/async';
 
+import { fetchWithDesktopRemoteRPC } from './helpers/desktopRemoteRPCFetch';
+
 export const asyncClient = createTRPCClient<AsyncRouter>({
   links: [
     httpBatchLink({
+      fetch: isDesktop
+        ? (input, init) => fetchWithDesktopRemoteRPC(input as string, init)
+        : undefined,
       maxURLLength: 2083,
       transformer: superjson,
       url: '/trpc/async',

package/src/libs/trpc/client/edge.ts

@@ -1,12 +1,18 @@
 import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import superjson from 'superjson';
 
+import { isDesktop } from '@/const/version';
 import type { EdgeRouter } from '@/server/routers/edge';
 import { withBasePath } from '@/utils/basePath';
 
+import { fetchWithDesktopRemoteRPC } from './helpers/desktopRemoteRPCFetch';
+
 export const edgeClient = createTRPCClient<EdgeRouter>({
   links: [
     httpBatchLink({
+      fetch: isDesktop
+        ? (input, init) => fetchWithDesktopRemoteRPC(input as string, init)
+        : undefined,
       headers: async () => {
         // dynamic import to avoid circular dependency
         const { createHeaderWithAuth } = await import('@/services/_auth');

package/src/libs/trpc/client/helpers/desktopRemoteRPCFetch.ts

@@ -0,0 +1,72 @@
+import { ProxyTRPCRequestParams, dispatch } from '@lobechat/electron-client-ipc';
+import debug from 'debug';
+
+import { isDesktop } from '@/const/version';
+import { getElectronStoreState } from '@/store/electron';
+import { electronSyncSelectors } from '@/store/electron/selectors';
+import { getRequestBody, headersToRecord } from '@/utils/fetch';
+
+const log = debug('lobe-lambda:desktopRemoteRPCFetch');
+
+// eslint-disable-next-line no-undef
+export const desktopRemoteRPCFetch = async (input: string, init?: RequestInit) => {
+  const isSyncActive = electronSyncSelectors.isSyncActive(getElectronStoreState());
+  log('isDesktop:', isDesktop, 'isSyncActive:', isSyncActive);
+
+  if (isSyncActive) {
+    log('Using IPC proxy for tRPC request');
+    try {
+      const url = input as string;
+      const parsedUrl = new URL(url, window.location.origin);
+      const urlPath = parsedUrl.pathname + parsedUrl.search;
+      const method = init?.method?.toUpperCase() || 'GET';
+      const headers = headersToRecord(init?.headers);
+      const body = await getRequestBody(init?.body);
+
+      const params: ProxyTRPCRequestParams = {
+        body,
+        headers,
+        method,
+        urlPath,
+      };
+
+      const ipcResult = await dispatch('proxyTRPCRequest', params);
+
+      log('Received IPC proxy response:', { status: ipcResult.status });
+      const response = new Response(ipcResult.body, {
+        headers: ipcResult.headers,
+        status: ipcResult.status,
+        statusText: ipcResult.statusText,
+      });
+
+      if (!response.ok) {
+        console.warn(
+          '[lambda] IPC proxy response indicates an error:',
+          response.status,
+          response.statusText,
+        );
+      }
+
+      return response;
+    } catch (error) {
+      console.error('[lambda] Error during IPC proxy call:', error);
+      return new Response(
+        `IPC Proxy Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        {
+          status: 500,
+          statusText: 'IPC Proxy Error',
+        },
+      );
+    }
+  }
+};
+
+// eslint-disable-next-line no-undef
+export const fetchWithDesktopRemoteRPC = async (input: string, init?: RequestInit) => {
+  if (isDesktop) {
+    const res = await desktopRemoteRPCFetch(input as string, init);
+    if (res) return res;
+  }
+
+  return fetch(input, init);
+};

package/src/libs/trpc/client/index.ts

@@ -1,4 +1,5 @@
 export { asyncClient } from './async';
+export * from './desktop';
 export { edgeClient } from './edge';
 export * from './lambda';
 export * from './tools';