@lobehub/lobehub 2.0.0-next.353 → 2.0.0-next.355

package/.agents/skills/add-provider-doc/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: add-provider-doc
+description: Guide for adding new AI provider documentation. Use when adding documentation for a new AI provider (like OpenAI, Anthropic, etc.), including usage docs, environment variables, Docker config, and image resources. Triggers on provider documentation tasks.
+---
+
+# Adding New AI Provider Documentation
+
+Complete workflow for adding documentation for a new AI provider.
+
+## Overview
+
+1. Create usage documentation (EN + CN)
+2. Add environment variable documentation (EN + CN)
+3. Update Docker configuration files
+4. Update .env.example
+5. Prepare image resources
+
+## Step 1: Create Provider Usage Documentation
+
+### Required Files
+
+- `docs/usage/providers/{provider-name}.mdx` (English)
+- `docs/usage/providers/{provider-name}.zh-CN.mdx` (Chinese)
+
+### Key Requirements
+
+- 5-6 screenshots showing the process
+- Cover image for the provider
+- Real registration and dashboard URLs
+- Pricing information callout
+- **Never include real API keys** - use placeholders
+
+Reference: `docs/usage/providers/fal.mdx`
+
+## Step 2: Update Environment Variables Documentation
+
+### Files to Update
+
+- `docs/self-hosting/environment-variables/model-provider.mdx` (EN)
+- `docs/self-hosting/environment-variables/model-provider.zh-CN.mdx` (CN)
+
+### Content Format
+
+```markdown
+### `{PROVIDER}_API_KEY`
+- Type: Required
+- Description: API key from {Provider Name}
+- Example: `{api-key-format}`
+
+### `{PROVIDER}_MODEL_LIST`
+- Type: Optional
+- Description: Control model list. Use `+` to add, `-` to hide
+- Example: `-all,+model-1,+model-2=Display Name`
+```
+
+## Step 3: Update Docker Files
+
+Update all Dockerfiles at the **end** of ENV section:
+
+- `Dockerfile`
+- `Dockerfile.database`
+- `Dockerfile.pglite`
+
+```dockerfile
+# {New Provider}
+{PROVIDER}_API_KEY="" {PROVIDER}_MODEL_LIST=""
+```
+
+## Step 4: Update .env.example
+
+```bash
+### {Provider Name} ###
+# {PROVIDER}_API_KEY={prefix}-xxxxxxxx
+```
+
+## Step 5: Image Resources
+
+- Cover image
+- 3-4 API dashboard screenshots
+- 2-3 LobeChat configuration screenshots
+- Host on LobeHub CDN: `hub-apac-1.lobeobjects.space`
+
+## Checklist
+
+- [ ] EN + CN usage docs
+- [ ] EN + CN env var docs
+- [ ] All 3 Dockerfiles updated
+- [ ] .env.example updated
+- [ ] All images prepared
+- [ ] No real API keys in docs

package/.agents/skills/add-setting-env/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: add-setting-env
+description: Guide for adding environment variables to configure user settings. Use when implementing server-side environment variables that control default values for user settings. Triggers on env var configuration or setting default value tasks.
+---
+
+# Adding Environment Variable for User Settings
+
+Add server-side environment variables to configure default values for user settings.
+
+**Priority**: User Custom > Server Env Var > Hardcoded Default
+
+## Steps
+
+### 1. Define Environment Variable
+
+Create `src/envs/<domain>.ts`:
+
+```typescript
+import { createEnv } from '@t3-oss/env-nextjs';
+import { z } from 'zod';
+
+export const get<Domain>Config = () => {
+  return createEnv({
+    server: {
+      YOUR_ENV_VAR: z.coerce.number().min(MIN).max(MAX).optional(),
+    },
+    runtimeEnv: {
+      YOUR_ENV_VAR: process.env.YOUR_ENV_VAR,
+    },
+  });
+};
+
+export const <domain>Env = get<Domain>Config();
+```
+
+### 2. Update Type (if new domain)
+
+Add to `packages/types/src/serverConfig.ts`:
+
+```typescript
+import { User<Domain>Config } from './user/settings';
+
+export interface GlobalServerConfig {
+  <domain>?: PartialDeep<User<Domain>Config>;
+}
+```
+
+**Prefer reusing existing types** from `packages/types/src/user/settings`.
+
+### 3. Assemble Server Config (if new domain)
+
+In `src/server/globalConfig/index.ts`:
+
+```typescript
+import { <domain>Env } from '@/envs/<domain>';
+
+export const getServerGlobalConfig = async () => {
+  const config: GlobalServerConfig = {
+    <domain>: cleanObject({
+      <settingName>: <domain>Env.YOUR_ENV_VAR,
+    }),
+  };
+  return config;
+};
+```
+
+### 4. Merge to User Store (if new domain)
+
+In `src/store/user/slices/common/action.ts`:
+
+```typescript
+const serverSettings: PartialDeep<UserSettings> = {
+  <domain>: serverConfig.<domain>,
+};
+```
+
+### 5. Update .env.example
+
+```bash
+# <Description> (range/options, default: X)
+# YOUR_ENV_VAR=<example>
+```
+
+### 6. Update Documentation
+
+- `docs/self-hosting/environment-variables/basic.mdx` (EN)
+- `docs/self-hosting/environment-variables/basic.zh-CN.mdx` (CN)
+
+## Example: AI_IMAGE_DEFAULT_IMAGE_NUM
+
+```typescript
+// src/envs/image.ts
+AI_IMAGE_DEFAULT_IMAGE_NUM: z.coerce.number().min(1).max(20).optional(),
+
+// packages/types/src/serverConfig.ts
+image?: PartialDeep<UserImageConfig>;
+
+// src/server/globalConfig/index.ts
+image: cleanObject({ defaultImageNum: imageEnv.AI_IMAGE_DEFAULT_IMAGE_NUM }),
+
+// src/store/user/slices/common/action.ts
+image: serverConfig.image,
+
+// .env.example
+# AI_IMAGE_DEFAULT_IMAGE_NUM=4
+```

package/.agents/skills/debug/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: debug
+description: Debug package usage guide. Use when adding debug logging, understanding log namespaces, or implementing debugging features. Triggers on debug logging requests or logging implementation.
+user-invocable: false
+---
+
+# Debug Package Usage Guide
+
+## Basic Usage
+
+```typescript
+import debug from 'debug';
+
+// Format: lobe-[module]:[submodule]
+const log = debug('lobe-server:market');
+
+log('Simple message');
+log('With variable: %O', object);
+log('Formatted number: %d', number);
+```
+
+## Namespace Conventions
+
+- Desktop: `lobe-desktop:[module]`
+- Server: `lobe-server:[module]`
+- Client: `lobe-client:[module]`
+- Router: `lobe-[type]-router:[module]`
+
+## Format Specifiers
+
+- `%O` - Object expanded (recommended for complex objects)
+- `%o` - Object
+- `%s` - String
+- `%d` - Number
+
+## Enable Debug Output
+
+### Browser
+
+```javascript
+localStorage.debug = 'lobe-*';
+```
+
+### Node.js
+
+```bash
+DEBUG=lobe-* npm run dev
+DEBUG=lobe-* pnpm dev
+```
+
+### Electron
+
+```typescript
+process.env.DEBUG = 'lobe-*';
+```
+
+## Example
+
+```typescript
+// src/server/routers/edge/market/index.ts
+import debug from 'debug';
+
+const log = debug('lobe-edge-router:market');
+
+log('getAgent input: %O', input);
+```

package/.agents/skills/desktop/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: desktop
+description: Electron desktop development guide. Use when implementing desktop features, IPC handlers, controllers, preload scripts, window management, menu configuration, or Electron-specific functionality. Triggers on desktop app development, Electron IPC, or desktop local tools implementation.
+disable-model-invocation: true
+---
+
+# Desktop Development Guide
+
+## Architecture Overview
+
+LobeChat desktop is built on Electron with main-renderer architecture:
+
+1. **Main Process** (`apps/desktop/src/main`): App lifecycle, system APIs, window management
+2. **Renderer Process**: Reuses web code from `src/`
+3. **Preload Scripts** (`apps/desktop/src/preload`): Securely expose main process to renderer
+
+## Adding New Desktop Features
+
+### 1. Create Controller
+Location: `apps/desktop/src/main/controllers/`
+
+```typescript
+import { ControllerModule, IpcMethod } from '@/controllers';
+
+export default class NewFeatureCtr extends ControllerModule {
+  static override readonly groupName = 'newFeature';
+
+  @IpcMethod()
+  async doSomething(params: SomeParams): Promise<SomeResult> {
+    // Implementation
+    return { success: true };
+  }
+}
+```
+
+Register in `apps/desktop/src/main/controllers/registry.ts`.
+
+### 2. Define IPC Types
+Location: `packages/electron-client-ipc/src/types.ts`
+
+```typescript
+export interface SomeParams { /* ... */ }
+export interface SomeResult { success: boolean; error?: string }
+```
+
+### 3. Create Renderer Service
+Location: `src/services/electron/`
+
+```typescript
+import { ensureElectronIpc } from '@/utils/electron/ipc';
+
+const ipc = ensureElectronIpc();
+
+export const newFeatureService = async (params: SomeParams) => {
+  return ipc.newFeature.doSomething(params);
+};
+```
+
+### 4. Implement Store Action
+Location: `src/store/`
+
+### 5. Add Tests
+Location: `apps/desktop/src/main/controllers/__tests__/`
+
+## Detailed Guides
+
+See `references/` for specific topics:
+- **Feature implementation**: `references/feature-implementation.md`
+- **Local tools workflow**: `references/local-tools.md`
+- **Menu configuration**: `references/menu-config.md`
+- **Window management**: `references/window-management.md`
+
+## Best Practices
+
+1. **Security**: Validate inputs, limit exposed APIs
+2. **Performance**: Use async methods, batch data transfers
+3. **UX**: Add progress indicators, provide error feedback
+4. **Code organization**: Follow existing patterns, add documentation

package/.agents/skills/desktop/references/feature-implementation.md

@@ -0,0 +1,99 @@
+# Desktop Feature Implementation Guide
+
+## Architecture Overview
+
+```plaintext
+Main Process                    Renderer Process
+┌──────────────────┐           ┌──────────────────┐
+│ Controller       │◄──IPC───►│ Service Layer    │
+│ (IPC Handler)    │           │                  │
+└──────────────────┘           └──────────────────┘
+        │                              │
+        ▼                              ▼
+┌──────────────────┐           ┌──────────────────┐
+│ System APIs      │           │ Store Actions    │
+│ (fs, network)    │           │ (UI State)       │
+└──────────────────┘           └──────────────────┘
+```
+
+## Step-by-Step Implementation
+
+### 1. Create Controller
+
+```typescript
+// apps/desktop/src/main/controllers/NotificationCtr.ts
+import type { ShowDesktopNotificationParams, DesktopNotificationResult } from '@lobechat/electron-client-ipc';
+import { Notification } from 'electron';
+import { ControllerModule, IpcMethod } from '@/controllers';
+
+export default class NotificationCtr extends ControllerModule {
+  static override readonly groupName = 'notification';
+
+  @IpcMethod()
+  async showDesktopNotification(params: ShowDesktopNotificationParams): Promise<DesktopNotificationResult> {
+    if (!Notification.isSupported()) {
+      return { error: 'Notifications not supported', success: false };
+    }
+
+    try {
+      const notification = new Notification({ body: params.body, title: params.title });
+      notification.show();
+      return { success: true };
+    } catch (error) {
+      console.error('[NotificationCtr] Failed:', error);
+      return { error: error instanceof Error ? error.message : 'Unknown error', success: false };
+    }
+  }
+}
+```
+
+### 2. Define IPC Types
+
+```typescript
+// packages/electron-client-ipc/src/types.ts
+export interface ShowDesktopNotificationParams {
+  title: string;
+  body: string;
+}
+
+export interface DesktopNotificationResult {
+  success: boolean;
+  error?: string;
+}
+```
+
+### 3. Create Service Layer
+
+```typescript
+// src/services/electron/notificationService.ts
+import type { ShowDesktopNotificationParams } from '@lobechat/electron-client-ipc';
+import { ensureElectronIpc } from '@/utils/electron/ipc';
+
+const ipc = ensureElectronIpc();
+
+export const notificationService = {
+  show: (params: ShowDesktopNotificationParams) =>
+    ipc.notification.showDesktopNotification(params),
+};
+```
+
+### 4. Implement Store Action
+
+```typescript
+// src/store/.../actions.ts
+showNotification: async (title: string, body: string) => {
+  if (!isElectron) return;
+
+  const result = await notificationService.show({ title, body });
+  if (!result.success) {
+    console.error('Notification failed:', result.error);
+  }
+},
+```
+
+## Best Practices
+
+1. **Security**: Validate inputs, limit exposed APIs
+2. **Performance**: Use async methods for heavy operations
+3. **Error handling**: Always return structured results
+4. **UX**: Provide loading states and error feedback

package/.agents/skills/desktop/references/local-tools.md

@@ -0,0 +1,133 @@
+# Desktop Local Tools Implementation
+
+## Workflow Overview
+
+1. Define tool interface (Manifest)
+2. Define related types
+3. Implement Store Action
+4. Implement Service Layer
+5. Implement Controller (IPC Handler)
+6. Update Agent documentation
+
+## Step 1: Define Tool Interface (Manifest)
+
+Location: `src/tools/[tool_category]/index.ts`
+
+```typescript
+// src/tools/local-files/index.ts
+export const LocalFilesApiName = {
+  RenameFile: 'renameFile',
+  MoveFile: 'moveFile',
+} as const;
+
+export const LocalFilesManifest = {
+  api: [
+    {
+      name: LocalFilesApiName.RenameFile,
+      description: 'Rename a local file',
+      parameters: {
+        type: 'object',
+        properties: {
+          oldPath: { type: 'string', description: 'Current file path' },
+          newName: { type: 'string', description: 'New file name' },
+        },
+        required: ['oldPath', 'newName'],
+      },
+    },
+  ],
+};
+```
+
+## Step 2: Define Types
+
+```typescript
+// packages/electron-client-ipc/src/types.ts
+export interface RenameLocalFileParams {
+  oldPath: string;
+  newName: string;
+}
+
+// src/tools/local-files/type.ts
+export interface LocalRenameFileState {
+  success: boolean;
+  error?: string;
+  oldPath: string;
+  newPath: string;
+}
+```
+
+## Step 3: Implement Store Action
+
+```typescript
+// src/store/chat/slices/builtinTool/actions/localFile.ts
+renameLocalFile: async (id: string, params: RenameLocalFileParams) => {
+  const { toggleLocalFileLoading, updatePluginState, internal_updateMessageContent } = get();
+
+  toggleLocalFileLoading(id, true);
+
+  try {
+    const result = await localFileService.renameFile(params);
+
+    if (result.success) {
+      updatePluginState(id, { success: true, ...result });
+      internal_updateMessageContent(id, JSON.stringify({ success: true }));
+    } else {
+      updatePluginState(id, { success: false, error: result.error });
+      internal_updateMessageContent(id, JSON.stringify({ error: result.error }));
+    }
+
+    return result.success;
+  } catch (e) {
+    console.error(e);
+    updatePluginState(id, { success: false, error: e.message });
+    return false;
+  } finally {
+    toggleLocalFileLoading(id, false);
+  }
+},
+```
+
+## Step 4: Implement Service Layer
+
+```typescript
+// src/services/electron/localFileService.ts
+import { ensureElectronIpc } from '@/utils/electron/ipc';
+
+const ipc = ensureElectronIpc();
+
+export const localFileService = {
+  renameFile: (params: RenameLocalFileParams) => ipc.localFiles.renameFile(params),
+};
+```
+
+## Step 5: Implement Controller
+
+```typescript
+// apps/desktop/src/main/controllers/LocalFileCtr.ts
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ControllerModule, IpcMethod } from '@/controllers';
+
+export default class LocalFileCtr extends ControllerModule {
+  static override readonly groupName = 'localFiles';
+
+  @IpcMethod()
+  async renameFile(params: RenameLocalFileParams) {
+    const { oldPath, newName } = params;
+    const newPath = path.join(path.dirname(oldPath), newName);
+
+    try {
+      await fs.rename(oldPath, newPath);
+      return { success: true, newPath };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+}
+```
+
+## Step 6: Update Agent Documentation
+
+Location: `src/tools/[tool_category]/systemRole.ts`
+
+Add tool description to `<core_capabilities>` and usage guidelines to `<tool_usage_guidelines>`.

package/.agents/skills/desktop/references/menu-config.md

@@ -0,0 +1,103 @@
+# Desktop Menu Configuration Guide
+
+## Menu Types
+
+1. **App Menu**: Top of window (macOS) or title bar (Windows/Linux)
+2. **Context Menu**: Right-click menus
+3. **Tray Menu**: System tray icon menus
+
+## File Structure
+
+```plaintext
+apps/desktop/src/main/
+├── menus/
+│   ├── appMenu.ts        # App menu config
+│   ├── contextMenu.ts    # Context menu config
+│   └── factory.ts        # Menu factory functions
+├── controllers/
+│   ├── MenuCtr.ts        # Menu controller
+│   └── TrayMenuCtr.ts    # Tray menu controller
+```
+
+## App Menu Configuration
+
+```typescript
+// apps/desktop/src/main/menus/appMenu.ts
+import { BrowserWindow, Menu, MenuItemConstructorOptions } from 'electron';
+
+export const createAppMenu = (win: BrowserWindow) => {
+  const template: MenuItemConstructorOptions[] = [
+    {
+      label: 'File',
+      submenu: [
+        { label: 'New', accelerator: 'CmdOrCtrl+N', click: () => { /* ... */ } },
+        { type: 'separator' },
+        { role: 'quit' },
+      ],
+    },
+    // ...
+  ];
+
+  return Menu.buildFromTemplate(template);
+};
+
+// Register in MenuCtr.ts
+Menu.setApplicationMenu(menu);
+```
+
+## Context Menu
+
+```typescript
+export const createContextMenu = () => {
+  const template = [
+    { label: 'Copy', role: 'copy' },
+    { label: 'Paste', role: 'paste' },
+  ];
+  return Menu.buildFromTemplate(template);
+};
+
+// Show on right-click
+const menu = createContextMenu();
+menu.popup();
+```
+
+## Tray Menu
+
+```typescript
+// TrayMenuCtr.ts
+this.tray = new Tray(trayIconPath);
+const contextMenu = Menu.buildFromTemplate([
+  { label: 'Show Window', click: this.showMainWindow },
+  { type: 'separator' },
+  { label: 'Quit', click: () => app.quit() },
+]);
+this.tray.setContextMenu(contextMenu);
+```
+
+## i18n Support
+
+```typescript
+import { i18n } from '../locales';
+
+const template = [
+  {
+    label: i18n.t('menu.file'),
+    submenu: [
+      { label: i18n.t('menu.new'), click: createNew },
+    ],
+  },
+];
+```
+
+## Best Practices
+
+1. Use standard roles (`role: 'copy'`) for native behavior
+2. Use `CmdOrCtrl` for cross-platform shortcuts
+3. Use `{ type: 'separator' }` to group related items
+4. Handle platform differences with `process.platform`
+
+```typescript
+if (process.platform === 'darwin') {
+  template.unshift({ role: 'appMenu' });
+}
+```