@lobehub/lobehub 2.0.0-next.241 → 2.0.0-next.243

package/src/locales/default/subscription.ts

@@ -132,10 +132,9 @@ export default {
     'Your {{plan}} computing credits have been exhausted. Upgrade now to get more credits.',
   'limitation.limited.descUltimate':
     'Your {{plan}} computing credits have been exhausted. Please top up credits to continue.',
-  'limitation.limited.referralTip':
-    'Invite new users to register, and you and your friend will each receive {{reward}}M credits',
+  'limitation.limited.referralTip': 'Invite friends, both get {{reward}}M',
   'limitation.limited.title': 'Computing Credits Exhausted',
-  'limitation.limited.topup': 'Top Up Credits',
+  'limitation.limited.topup': 'Top-Up Credits',
   'limitation.limited.upgrade': 'Upgrade to Higher Plan',
   'limitation.providers.lock.addNew': 'Subscribe now to create custom AI providers',
   'limitation.providers.lock.enableProvider': 'Subscribe now to enable this AI provider',

package/src/server/services/memory/userMemory/extract.ts

@@ -66,6 +66,7 @@ import type { GlobalMemoryLayer } from '@/types/serverConfig';
 import type { UserKeyVaults } from '@/types/user/settings';
 import { LayersEnum, type MergeStrategyEnum, TypesEnum, MemorySourceType } from '@/types/userMemory';
 import { encodeAsync } from '@/utils/tokenizer';
+import debug from 'debug';
 
 const SOURCE_ALIAS_MAP: Record<string, MemorySourceType> = {
   benchmark_locomo: MemorySourceType.BenchmarkLocomo,
@@ -262,19 +263,58 @@ const resolveLayerModels = (
   preference: layers?.preference ?? fallback.preference,
 });
 
-const initRuntimeForAgent = async (agent: MemoryAgentConfig, keyVaults?: UserKeyVaults) => {
+const maskSecret = (value?: string) => {
+  if (!value) return 'undefined';
+  if (value.length <= 8) return `${value[0]}***${value.at(-1)}`;
+
+  return `${value.slice(0, 6)}***${value.slice(-4)}`;
+};
+
+const resolveRuntimeAgentConfig = (agent: MemoryAgentConfig, keyVaults?: UserKeyVaults) => {
   const provider = agent.provider || 'openai';
   const { apiKey: userApiKey, baseURL: userBaseURL } = extractCredentialsFromVault(
     provider,
     keyVaults,
   );
 
-  const apiKey = userApiKey || agent.apiKey;
-  if (!apiKey) throw new Error(`Missing API key for ${provider} memory extraction runtime`);
+  // Only use the user baseURL if we are also using their API key; otherwise fall back entirely
+  // to system config to avoid mixing credentials.
+  const useUserCredential = !!userApiKey;
+  const apiKey = useUserCredential ? userApiKey : agent.apiKey;
+  const baseURL = useUserCredential ? userBaseURL || agent.baseURL : agent.baseURL;
+  const source = useUserCredential ? 'user-keyvault' : 'system-config';
+
+  return { apiKey, baseURL, provider, source };
+};
+
+const logRuntime = debug('lobe-server:memory:user-memory:runtime');
+
+const debugRuntimeInit = (
+  agent: MemoryAgentConfig,
+  resolved: ReturnType<typeof resolveRuntimeAgentConfig>,
+) => {
+  if (!logRuntime.enabled) return;
+  logRuntime('init runtime', {
+    agentModel: agent.model,
+    agentProvider: agent.provider || 'openai',
+    apiKey: maskSecret(resolved.apiKey),
+    baseURL: resolved.baseURL,
+    provider: resolved.provider,
+    source: resolved.source,
+  });
+};
+
+const initRuntimeForAgent = async (agent: MemoryAgentConfig, keyVaults?: UserKeyVaults) => {
+  const resolved = resolveRuntimeAgentConfig(agent, keyVaults);
+  debugRuntimeInit(agent, resolved);
+
+  if (!resolved.apiKey) {
+    throw new Error(`Missing API key for ${resolved.provider} memory extraction runtime`);
+  }
 
-  return ModelRuntime.initializeWithProvider(provider, {
-    apiKey,
-    baseURL: userBaseURL || agent.baseURL,
+  return ModelRuntime.initializeWithProvider(resolved.provider, {
+    apiKey: resolved.apiKey,
+    baseURL: resolved.baseURL,
   });
 };
 

package/apps/desktop/src/main/controllers/UploadFileServerCtr.ts

@@ -1,33 +0,0 @@
-import { CreateFileParams } from '@lobechat/electron-server-ipc';
-
-import FileService from '@/services/fileSrv';
-
-import { ControllerModule, IpcServerMethod } from './index';
-
-export default class UploadFileServerCtr extends ControllerModule {
-  static override readonly groupName = 'upload';
-
-  private get fileService() {
-    return this.app.getService(FileService);
-  }
-
-  @IpcServerMethod()
-  async getFileUrlById(id: string) {
-    return this.fileService.getFilePath(id);
-  }
-
-  @IpcServerMethod()
-  async getFileHTTPURL(path: string) {
-    return this.fileService.getFileHTTPURL(path);
-  }
-
-  @IpcServerMethod()
-  async deleteFiles(paths: string[]) {
-    return this.fileService.deleteFiles(paths);
-  }
-
-  @IpcServerMethod()
-  async createFile(params: CreateFileParams) {
-    return this.fileService.uploadFile(params);
-  }
-}

package/apps/desktop/src/main/controllers/__tests__/UploadFileServerCtr.test.ts

@@ -1,55 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type { App } from '@/core/App';
-
-import UploadFileServerCtr from '../UploadFileServerCtr';
-
-vi.mock('@/services/fileSrv', () => ({
-  default: class MockFileService {},
-}));
-
-const mockFileService = {
-  getFileHTTPURL: vi.fn(),
-  getFilePath: vi.fn(),
-  deleteFiles: vi.fn(),
-  uploadFile: vi.fn(),
-};
-
-const mockApp = {
-  getService: vi.fn(() => mockFileService),
-} as unknown as App;
-
-describe('UploadFileServerCtr', () => {
-  let controller: UploadFileServerCtr;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    controller = new UploadFileServerCtr(mockApp);
-  });
-
-  it('gets file path by id', async () => {
-    mockFileService.getFilePath.mockResolvedValue('path');
-    await expect(controller.getFileUrlById('id')).resolves.toBe('path');
-    expect(mockFileService.getFilePath).toHaveBeenCalledWith('id');
-  });
-
-  it('gets HTTP URL', async () => {
-    mockFileService.getFileHTTPURL.mockResolvedValue('url');
-    await expect(controller.getFileHTTPURL('/path')).resolves.toBe('url');
-    expect(mockFileService.getFileHTTPURL).toHaveBeenCalledWith('/path');
-  });
-
-  it('deletes files', async () => {
-    mockFileService.deleteFiles.mockResolvedValue(undefined);
-    await controller.deleteFiles(['a']);
-    expect(mockFileService.deleteFiles).toHaveBeenCalledWith(['a']);
-  });
-
-  it('creates files via upload service', async () => {
-    const params = { filename: 'file' } as any;
-    mockFileService.uploadFile.mockResolvedValue({ success: true });
-
-    await expect(controller.createFile(params)).resolves.toEqual({ success: true });
-    expect(mockFileService.uploadFile).toHaveBeenCalledWith(params);
-  });
-});

package/src/server/modules/ElectronIPCClient/index.ts

@@ -1,92 +0,0 @@
-import { type CreateFileParams, ElectronIpcClient, type FileMetadata } from '@lobechat/electron-server-ipc';
-import type { DesktopServerIpcServices } from '@lobehub/desktop-ipc-typings';
-
-import packageJSON from '@/../apps/desktop/package.json';
-
-const createServerInvokeProxy = <IpcServices>(
-  invoke: (channel: string, payload?: unknown) => Promise<unknown>,
-): IpcServices =>
-  new Proxy(
-    {},
-    {
-      get(_target, groupKey) {
-        if (typeof groupKey !== 'string') return undefined;
-
-        return new Proxy(
-          {},
-          {
-            get(_methodTarget, methodKey) {
-              if (typeof methodKey !== 'string') return undefined;
-
-              const channel = `${groupKey}.${methodKey}`;
-              return (payload?: unknown) =>
-                payload === undefined ? invoke(channel) : invoke(channel, payload);
-            },
-          },
-        );
-      },
-    },
-  ) as IpcServices;
-
-class LobeHubElectronIpcClient extends ElectronIpcClient {
-  private _services: DesktopServerIpcServices | null = null;
-
-  private ensureServices(): DesktopServerIpcServices {
-    if (this._services) return this._services;
-
-    this._services = createServerInvokeProxy<DesktopServerIpcServices>((channel, payload) =>
-      payload === undefined ? this.sendRequest(channel) : this.sendRequest(channel, payload),
-    );
-
-    return this.services;
-  }
-
-  private get ipc() {
-    return this.ensureServices();
-  }
-
-  public get services(): DesktopServerIpcServices {
-    return this.ipc;
-  }
-
-  getDatabasePath = async (): Promise<string> => {
-    return this.ipc.system.getDatabasePath();
-  };
-
-  getUserDataPath = async (): Promise<string> => {
-    return this.ipc.system.getUserDataPath();
-  };
-
-  getDatabaseSchemaHash = async () => {
-    return this.ipc.system.getDatabaseSchemaHash();
-  };
-
-  setDatabaseSchemaHash = async (hash: string | undefined) => {
-    if (!hash) return;
-
-    return this.ipc.system.setDatabaseSchemaHash(hash);
-  };
-
-  getFilePathById = async (id: string) => {
-    return this.ipc.upload.getFileUrlById(id);
-  };
-
-  getFileHTTPURL = async (path: string) => {
-    return this.ipc.upload.getFileHTTPURL(path);
-  };
-
-  deleteFiles = async (paths: string[]) => {
-    return this.ipc.upload.deleteFiles(paths);
-  };
-
-  createFile = async (params: CreateFileParams) => {
-    return this.ipc.upload.createFile(params) as Promise<{
-      metadata: FileMetadata;
-      success: boolean;
-    }>;
-  };
-}
-
-export const electronIpcClient = new LobeHubElectronIpcClient(packageJSON.name);
-
-export const ensureElectronServerIpc = (): DesktopServerIpcServices => electronIpcClient.services;