@lobehub/chat 1.82.0 → 1.82.1

package/src/services/user/index.ts

@@ -1,3 +1,5 @@
+import { isDesktop } from '@/const/version';
+
 import { ClientService as DeprecatedService } from './_deprecated';
 import { ClientService } from './client';
 import { ServerService } from './server';
@@ -6,6 +8,8 @@ const clientService =
   process.env.NEXT_PUBLIC_CLIENT_DB === 'pglite' ? new ClientService() : new DeprecatedService();
 
 export const userService =
-  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' ? new ServerService() : clientService;
+  process.env.NEXT_PUBLIC_SERVICE_MODE === 'server' || isDesktop
+    ? new ServerService()
+    : clientService;
 
 export const userClientService = clientService;

package/src/store/electron/actions/app.ts

@@ -0,0 +1,59 @@
+import { ElectronAppState } from '@lobechat/electron-client-ipc';
+import { SWRResponse } from 'swr';
+import { StateCreator } from 'zustand/vanilla';
+
+import { useOnlyFetchOnceSWR } from '@/libs/swr';
+// Import for type usage
+import { electronSystemService } from '@/services/electron/system';
+import { globalAgentContextManager } from '@/utils/client/GlobalAgentContextManager';
+
+import { ElectronStore } from '../store';
+
+// Import the new service
+
+// ======== State ======== //
+
+// Note: Actual state is defined in initialState.ts and ElectronState interface
+
+// ======== Action Interface ======== //
+
+export interface ElectronAppAction {
+  /**
+   * Initializes the basic Electron application state, including system info and special paths.
+   * Should be called once when the application starts.
+   */
+  useInitElectronAppState: () => SWRResponse<ElectronAppState>;
+}
+
+// ======== Action Implementation ======== //
+
+export const createElectronAppSlice: StateCreator<
+  ElectronStore,
+  [['zustand/devtools', never]],
+  [],
+  ElectronAppAction
+> = (set) => ({
+  useInitElectronAppState: () =>
+    useOnlyFetchOnceSWR<ElectronAppState>(
+      'initElectronAppState',
+      async () => electronSystemService.getAppState(),
+      {
+        onSuccess: (result) => {
+          set({ appState: result }, false, 'initElectronAppState');
+
+          // Update the global agent context manager with relevant paths
+          // We typically only need paths in the agent context for now.
+          globalAgentContextManager.updateContext({
+            desktopPath: result.userPath!.desktop,
+            documentsPath: result.userPath!.documents,
+            downloadsPath: result.userPath!.downloads,
+            homePath: result.userPath!.home,
+            musicPath: result.userPath!.music,
+            picturesPath: result.userPath!.pictures,
+            userDataPath: result.userPath!.userData,
+            videosPath: result.userPath!.videos,
+          });
+        },
+      },
+    ),
+});

package/src/store/electron/actions/sync.ts

@@ -109,8 +109,12 @@ export const remoteSyncSlice: StateCreator<
       },
       {
         onSuccess: (data) => {
+          console.log('remote server config:', data);
           set({ isInitRemoteServerConfig: true, remoteServerConfig: data });
-          get().refreshUserData();
+
+          if (data.active) {
+            get().refreshUserData();
+          }
         },
       },
     ),

package/src/store/electron/initialState.ts

@@ -1,8 +1,9 @@
-import { RemoteServerConfig } from '@lobechat/electron-client-ipc';
+import { ElectronAppState, RemoteServerConfig } from '@lobechat/electron-client-ipc';
 
 export type RemoteServerError = 'CONFIG_ERROR' | 'AUTH_ERROR' | 'DISCONNECT_ERROR';
 
 export interface ElectronState {
+  appState: ElectronAppState;
   isConnectingServer?: boolean;
   isInitRemoteServerConfig: boolean;
   isSyncActive?: boolean;
@@ -11,6 +12,7 @@ export interface ElectronState {
 }
 
 export const initialState: ElectronState = {
+  appState: {},
   isConnectingServer: false,
   isInitRemoteServerConfig: false,
   isSyncActive: false,

package/src/store/electron/store.ts

@@ -3,12 +3,16 @@ import { createWithEqualityFn } from 'zustand/traditional';
 import { StateCreator } from 'zustand/vanilla';
 
 import { createDevtools } from '../middleware/createDevtools';
+import { type ElectronAppAction, createElectronAppSlice } from './actions/app';
 import { type ElectronRemoteServerAction, remoteSyncSlice } from './actions/sync';
 import { type ElectronState, initialState } from './initialState';
 
 //  ===============  聚合 createStoreFn ============ //
 
-export interface ElectronStore extends ElectronState, ElectronRemoteServerAction {
+export interface ElectronStore
+  extends ElectronState,
+    ElectronRemoteServerAction,
+    ElectronAppAction {
   /* empty */
 }
 
@@ -17,6 +21,7 @@ const createStore: StateCreator<ElectronStore, [['zustand/devtools', never]]> =
 ) => ({
   ...initialState,
   ...remoteSyncSlice(...parameters),
+  ...createElectronAppSlice(...parameters),
 });
 
 //  ===============  实装 useStore ============ //

package/src/store/tool/slices/customPlugin/action.ts

@@ -1,8 +1,10 @@
+import { LobeChatPluginManifest } from '@lobehub/chat-plugin-sdk';
 import { t } from 'i18next';
 import { merge } from 'lodash-es';
 import { StateCreator } from 'zustand/vanilla';
 
 import { notification } from '@/components/AntdStaticMethods';
+import { mcpService } from '@/services/mcp';
 import { pluginService } from '@/services/plugin';
 import { toolService } from '@/services/tool';
 import { pluginHelpers } from '@/store/tool/helpers';
@@ -40,12 +42,22 @@ export const createCustomPluginSlice: StateCreator<
     if (!plugin) return;
 
     const { refreshPlugins, updateInstallLoadingState } = get();
+
     try {
       updateInstallLoadingState(id, true);
-      const manifest = await toolService.getToolManifest(
-        plugin.customParams?.manifestUrl,
-        plugin.customParams?.useProxy,
-      );
+      let manifest: LobeChatPluginManifest;
+      // mean this is a mcp plugin
+      if (!!plugin.customParams?.mcp) {
+        const url = plugin.customParams?.mcp?.url;
+        if (!url) return;
+
+        manifest = await mcpService.getStreamableMcpServerManifest(plugin.identifier, url);
+      } else {
+        manifest = await toolService.getToolManifest(
+          plugin.customParams?.manifestUrl,
+          plugin.customParams?.useProxy,
+        );
+      }
       updateInstallLoadingState(id, false);
 
       await pluginService.updatePluginManifest(id, manifest);

package/src/utils/client/GlobalAgentContextManager.ts

@@ -0,0 +1,85 @@
+export interface LobeGlobalAgentContext {
+  // Other potential context
+  currentTime?: string;
+
+  // App's data directory
+  // Paths commonly used by agents
+  desktopPath?: string;
+  documentsPath?: string;
+  downloadsPath?: string;
+  homePath?: string;
+  musicPath?: string;
+  picturesPath?: string; // User's home directory
+  userDataPath?: string;
+
+  videosPath?: string;
+  // Add other global context properties needed by agents here
+}
+
+// Augment the Window interface to include our global context
+declare global {
+  interface Window {
+    __LOBE_GLOBAL_AGENT_CONTEXT__?: LobeGlobalAgentContext;
+  }
+}
+
+const CONTEXT_KEY = '__LOBE_GLOBAL_AGENT_CONTEXT__';
+
+class GlobalAgentContextManager {
+  private get context(): LobeGlobalAgentContext {
+    if (typeof window === 'undefined') return {};
+    if (!window[CONTEXT_KEY]) {
+      window[CONTEXT_KEY] = {};
+    }
+    return window[CONTEXT_KEY]!;
+  }
+
+  private set context(value: LobeGlobalAgentContext) {
+    if (typeof window === 'undefined') return;
+    window[CONTEXT_KEY] = value;
+  }
+
+  /**
+   * Retrieves the current global agent context.
+   */
+  public getContext(): LobeGlobalAgentContext {
+    return this.context;
+  }
+
+  /**
+   * Updates the global agent context by merging updates.
+   * This is typically called by the Electron store initializer.
+   * @param updates - Partial context updates to merge.
+   */
+  public updateContext(updates: Partial<LobeGlobalAgentContext>): void {
+    this.context = { ...this.context, ...updates };
+  }
+
+  /**
+   * Sets the entire global agent context, replacing the existing one.
+   * @param context - The new context object.
+   */
+  public setContext(context: LobeGlobalAgentContext): void {
+    this.context = context;
+  }
+
+  /**
+   * Fills a template string using the current global agent context.
+   * Replaces {{key}} placeholders with values from the context.
+   * @param template - The template string with placeholders.
+   * @returns The filled template string.
+   */
+  public fillTemplate(template?: string): string {
+    const ctx = this.getContext();
+    if (!template) return '';
+
+    // Updated to use replaceAll for potentially multiple occurrences
+    return template.replaceAll(/{{([^}]+)}}/g, (match, key) => {
+      const trimmedKey = key.trim() as keyof LobeGlobalAgentContext;
+      return ctx[trimmedKey] !== undefined ? String(ctx[trimmedKey]) : '[N/A]';
+    });
+  }
+}
+
+// Export a singleton instance for global use
+export const globalAgentContextManager = new GlobalAgentContextManager();

package/src/utils/promptTemplate.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+
+import { hydrationPrompt } from './promptTemplate';
+
+describe('hydrationPrompt', () => {
+  it('should replace basic variables', () => {
+    const prompt = 'Hello {{name}}!';
+    const context = { name: 'World' };
+    expect(hydrationPrompt(prompt, context)).toBe('Hello World!');
+  });
+
+  it('should replace missing variables with an empty string', () => {
+    const prompt = 'Hello {{name}}! Your age is {{age}}.';
+    const context = { name: 'World' };
+    expect(hydrationPrompt(prompt, context)).toBe('Hello World! Your age is .');
+  });
+
+  it('should replace nested variables', () => {
+    const prompt = 'User: {{user.name}}, Role: {{user.role.name}}';
+    const context = { user: { name: 'Alice', role: { name: 'Admin' } } };
+    expect(hydrationPrompt(prompt, context)).toBe('User: Alice, Role: Admin');
+  });
+
+  it('should handle missing nested variables gracefully', () => {
+    const prompt = 'User: {{user.name}}, City: {{user.address.city}}';
+    const context = { user: { name: 'Bob' } };
+    expect(hydrationPrompt(prompt, context)).toBe('User: Bob, City: ');
+  });
+
+  it('should handle multiple variables, some missing', () => {
+    const prompt = '{{greeting}} {{user.name}}. Welcome to {{place}}. Your id is {{id}}';
+    const context = { greeting: 'Hi', user: { name: 'Charlie' } };
+    expect(hydrationPrompt(prompt, context)).toBe('Hi Charlie. Welcome to . Your id is ');
+  });
+
+  it('should handle empty context', () => {
+    const prompt = 'Hello {{name}}!';
+    const context = {};
+    expect(hydrationPrompt(prompt, context)).toBe('Hello !');
+  });
+
+  it('should handle empty prompt string', () => {
+    const prompt = '';
+    const context = { name: 'World' };
+    expect(hydrationPrompt(prompt, context)).toBe('');
+  });
+
+  it('should handle prompt with no variables', () => {
+    const prompt = 'This is a plain string.';
+    const context = { name: 'World' };
+    expect(hydrationPrompt(prompt, context)).toBe('This is a plain string.');
+  });
+
+  it('should handle different data types in context', () => {
+    const prompt = 'Count: {{count}}, Active: {{isActive}}, User: {{user}}';
+    const context = { count: 123, isActive: true, user: null };
+    // Note: null becomes "null" when converted to string
+    expect(hydrationPrompt(prompt, context)).toBe('Count: 123, Active: true, User: null');
+  });
+
+  it('should handle keys with leading/trailing whitespace', () => {
+    const prompt = 'Value: {{  spacedKey  }}';
+    const context = { spacedKey: 'Trimmed' };
+    expect(hydrationPrompt(prompt, context)).toBe('Value: Trimmed');
+  });
+
+  it('should replace variables with undefined value with an empty string', () => {
+    const prompt = 'Name: {{name}}, Age: {{age}}';
+    const context = { name: 'Defined', age: undefined };
+    expect(hydrationPrompt(prompt, context)).toBe('Name: Defined, Age: ');
+  });
+
+  it('should handle complex nested structures and missing parts', () => {
+    const prompt = 'Data: {{a.b.c}}, Missing: {{x.y.z}}, Partial: {{a.b.d}}';
+    const context = { a: { b: { c: 'Found' } } };
+    expect(hydrationPrompt(prompt, context)).toBe('Data: Found, Missing: , Partial: ');
+  });
+});

package/src/utils/promptTemplate.ts

@@ -0,0 +1,17 @@
+import { get } from 'lodash-es';
+
+export const hydrationPrompt = (prompt: string, context: any) => {
+  const regex = /{{([\S\s]+?)}}/g;
+
+  // Use String.prototype.replace with a replacer function
+  return prompt.replaceAll(regex, (match, key) => {
+    const trimmedKey = key.trim();
+
+    // Safely get the value from the context, including nested paths
+    const value = get(context, trimmedKey);
+
+    // If the value exists (is not undefined), convert it to string and return.
+    // Otherwise, return an empty string to replace the placeholder.
+    return value !== undefined ? String(value) : '';
+  });
+};