@lobehub/lobehub 2.0.0-next.193 → 2.0.0-next.195

package/src/envs/app.ts

@@ -82,6 +82,7 @@ export const getAppConfig = () => {
        * @default false
        */
       enableQueueAgentRuntime: z.boolean().optional(),
+      TELEMETRY_DISABLED: z.boolean().optional(),
     },
     runtimeEnv: {
       // Sentry
@@ -121,6 +122,7 @@ export const getAppConfig = () => {
       MARKET_TRUSTED_CLIENT_ID: process.env.MARKET_TRUSTED_CLIENT_ID,
 
       enableQueueAgentRuntime: process.env.AGENT_RUNTIME_MODE === 'queue',
+      TELEMETRY_DISABLED: process.env.TELEMETRY_DISABLED === '1',
     },
   });
 };

package/src/libs/trpc/lambda/middleware/index.ts

@@ -1,3 +1,4 @@
 export * from './keyVaults';
 export * from './marketUserInfo';
 export * from './serverDatabase';
+export * from './telemetry';

package/src/libs/trpc/lambda/middleware/telemetry.test.ts

@@ -0,0 +1,237 @@
+// @vitest-environment node
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { appEnv } from '@/envs/app';
+
+import { TelemetryContext, checkTelemetryEnabled } from './telemetry';
+
+const { mockGetUserSettings, mockGetUserPreference, MockUserModel } = vi.hoisted(() => {
+  const mockGetUserSettings = vi.fn();
+  const mockGetUserPreference = vi.fn();
+  const MockUserModel = vi.fn().mockImplementation(() => ({
+    getUserPreference: mockGetUserPreference,
+    getUserSettings: mockGetUserSettings,
+  })) as any;
+  return { MockUserModel, mockGetUserPreference, mockGetUserSettings };
+});
+
+vi.mock('@/envs/app', () => ({
+  appEnv: {
+    TELEMETRY_DISABLED: false,
+  },
+}));
+
+vi.mock('@/database/models/user', () => ({
+  UserModel: MockUserModel,
+}));
+
+describe('checkTelemetryEnabled', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset appEnv mock
+    vi.mocked(appEnv).TELEMETRY_DISABLED = false;
+    // Default mock returns
+    mockGetUserSettings.mockResolvedValue(null);
+    mockGetUserPreference.mockResolvedValue(null);
+  });
+
+  describe('environment variable priority (highest)', () => {
+    it('should return telemetryEnabled: false when TELEMETRY_DISABLED=true', async () => {
+      vi.mocked(appEnv).TELEMETRY_DISABLED = true;
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      // Should not call database
+      expect(mockGetUserSettings).not.toHaveBeenCalled();
+    });
+
+    it('should check database when TELEMETRY_DISABLED is false', async () => {
+      await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(mockGetUserSettings).toHaveBeenCalled();
+    });
+
+    it('should check database when TELEMETRY_DISABLED is undefined', async () => {
+      vi.mocked(appEnv).TELEMETRY_DISABLED = undefined;
+
+      await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(mockGetUserSettings).toHaveBeenCalled();
+    });
+  });
+
+  describe('user_settings.general.telemetry', () => {
+    it('should return telemetryEnabled: true when settings.general.telemetry is true and preference is not set', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: true },
+      });
+      mockGetUserPreference.mockResolvedValue(null);
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+
+    it('should return telemetryEnabled: false from settings.general', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: false },
+      });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+    });
+
+    it('should check preference when settings.general.telemetry is not set', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { fontSize: 14 }, // no telemetry field
+      });
+      mockGetUserPreference.mockResolvedValue({ telemetry: true });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // Should fall back to preference.telemetry
+      expect(result).toEqual({ telemetryEnabled: true });
+      expect(mockGetUserPreference).toHaveBeenCalled();
+    });
+  });
+
+  describe('users.preference.telemetry (deprecated, fallback)', () => {
+    it('should return telemetryEnabled: true from preference.telemetry', async () => {
+      mockGetUserSettings.mockResolvedValue(null);
+      mockGetUserPreference.mockResolvedValue({ telemetry: true });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+
+    it('should return telemetryEnabled: false from preference.telemetry', async () => {
+      mockGetUserSettings.mockResolvedValue(null);
+      mockGetUserPreference.mockResolvedValue({ telemetry: false });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+    });
+
+    it('should use preference.telemetry when settings.general.telemetry is not false', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: true },
+      });
+      mockGetUserPreference.mockResolvedValue({ telemetry: false });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // preference.telemetry is checked when settings.general.telemetry is not false
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserPreference).toHaveBeenCalled();
+    });
+
+    it('should not call getUserPreference when settings.general.telemetry is explicitly false', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: { telemetry: false },
+      });
+      mockGetUserPreference.mockResolvedValue({ telemetry: true });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserPreference).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('default value', () => {
+    it('should default to true when settings is null', async () => {
+      mockGetUserSettings.mockResolvedValue(null);
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // Default to true (enabled) unless explicitly disabled
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+
+    it('should default to true when general is null', async () => {
+      mockGetUserSettings.mockResolvedValue({
+        general: null,
+      });
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      // Default to true (enabled) unless explicitly disabled
+      expect(result).toEqual({ telemetryEnabled: true });
+    });
+  });
+
+  describe('missing context', () => {
+    it('should return telemetryEnabled: false when userId is missing', async () => {
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: null,
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserSettings).not.toHaveBeenCalled();
+    });
+
+    it('should return telemetryEnabled: false when serverDB is missing', async () => {
+      const result = await checkTelemetryEnabled({
+        serverDB: undefined,
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+      expect(mockGetUserSettings).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should return telemetryEnabled: false when getUserSettings fails', async () => {
+      mockGetUserSettings.mockRejectedValue(new Error('Database error'));
+
+      const result = await checkTelemetryEnabled({
+        serverDB: {} as TelemetryContext['serverDB'],
+        userId: 'test-user',
+      });
+
+      expect(result).toEqual({ telemetryEnabled: false });
+    });
+  });
+});

package/src/libs/trpc/lambda/middleware/telemetry.ts

@@ -0,0 +1,74 @@
+import type { LobeChatDatabase } from '@lobechat/database';
+import type { UserGeneralConfig } from '@lobechat/types';
+
+import { UserModel } from '@/database/models/user';
+import { appEnv } from '@/envs/app';
+
+import { trpc } from '../init';
+
+export interface TelemetryContext {
+  serverDB?: LobeChatDatabase;
+  userId?: string | null;
+}
+
+export interface TelemetryResult {
+  telemetryEnabled: boolean;
+}
+
+/**
+ * Check if telemetry is enabled for the current user
+ *
+ * Priority:
+ * 1. Environment variable TELEMETRY_DISABLED=1 → telemetryEnabled: false (highest priority)
+ * 2. User settings from database user_settings.general.telemetry (new location)
+ * 3. User preference from database users.preference.telemetry (old location, deprecated)
+ * 4. Default to true if not explicitly set
+ */
+export const checkTelemetryEnabled = async (ctx: TelemetryContext): Promise<TelemetryResult> => {
+  // Priority 1: Check environment variable (highest priority)
+  if (appEnv.TELEMETRY_DISABLED) {
+    return { telemetryEnabled: false };
+  }
+
+  // If userId or serverDB is not available, default to disabled
+  if (!ctx.userId || !ctx.serverDB) {
+    return { telemetryEnabled: false };
+  }
+
+  try {
+    const userModel = new UserModel(ctx.serverDB, ctx.userId);
+
+    // Priority 2: Check user settings (new location: settings.general.telemetry)
+    const settings = await userModel.getUserSettings();
+    const generalConfig = settings?.general as UserGeneralConfig | null | undefined;
+
+    if (generalConfig?.telemetry === false) {
+      return { telemetryEnabled: false };
+    }
+
+    // Priority 3: Check user preference (old location: preference.telemetry)
+    const preference = await userModel.getUserPreference();
+
+    if (typeof preference?.telemetry === 'boolean') {
+      return { telemetryEnabled: preference?.telemetry };
+    }
+
+    // Priority 4: Default to true if not explicitly set
+    return { telemetryEnabled: true };
+  } catch {
+    // If fetching user settings fails, default to disabled
+    return { telemetryEnabled: false };
+  }
+};
+
+/**
+ * Middleware that checks if telemetry is enabled for the current user
+ * and adds telemetryEnabled to the context
+ *
+ * Requires serverDatabase middleware to be applied first
+ */
+export const telemetry = trpc.middleware(async (opts) => {
+  const result = await checkTelemetryEnabled(opts.ctx as TelemetryContext);
+
+  return opts.next({ ctx: result });
+});

package/src/server/routers/lambda/market/index.ts

@@ -4,15 +4,9 @@ import { serialize } from 'cookie';
 import debug from 'debug';
 import { z } from 'zod';
 
-import { type ToolCallContent } from '@/libs/mcp';
-import { authedProcedure, publicProcedure, router } from '@/libs/trpc/lambda';
+import { publicProcedure, router } from '@/libs/trpc/lambda';
 import { marketUserInfo, serverDatabase } from '@/libs/trpc/lambda/middleware';
 import { DiscoverService } from '@/server/services/discover';
-import { FileService } from '@/server/services/file';
-import {
-  contentBlocksToString,
-  processContentBlocks,
-} from '@/server/services/mcp/contentProcessor';
 import {
   AssistantSorts,
   McpConnectionType,
@@ -41,93 +35,7 @@ const marketProcedure = publicProcedure
     });
   });
 
-// Procedure with user authentication for operations requiring user access token
-const authedMarketProcedure = authedProcedure
-  .use(serverDatabase)
-  .use(marketUserInfo)
-  .use(async ({ ctx, next }) => {
-    const { UserModel } = await import('@/database/models/user');
-    const userModel = new UserModel(ctx.serverDB, ctx.userId);
-
-    return next({
-      ctx: {
-        discoverService: new DiscoverService({
-          accessToken: ctx.marketAccessToken,
-          userInfo: ctx.marketUserInfo,
-        }),
-        fileService: new FileService(ctx.serverDB, ctx.userId),
-        userModel,
-      },
-    });
-  });
-
 export const marketRouter = router({
-  // ============================== Cloud MCP Gateway ==============================
-  callCloudMcpEndpoint: authedMarketProcedure
-    .input(
-      z.object({
-        apiParams: z.record(z.any()),
-        identifier: z.string(),
-        toolName: z.string(),
-      }),
-    )
-    .mutation(async ({ input, ctx }) => {
-      log('callCloudMcpEndpoint input: %O', input);
-
-      try {
-        // Query user_settings to get market.accessToken
-        const userState = await ctx.userModel.getUserState(async () => ({}));
-        const userAccessToken = userState.settings?.market?.accessToken;
-
-        log('callCloudMcpEndpoint: userAccessToken exists=%s', !!userAccessToken);
-
-        if (!userAccessToken) {
-          throw new TRPCError({
-            code: 'UNAUTHORIZED',
-            message: 'User access token not found. Please sign in to Market first.',
-          });
-        }
-
-        const cloudResult = await ctx.discoverService.callCloudMcpEndpoint({
-          apiParams: input.apiParams,
-          identifier: input.identifier,
-          toolName: input.toolName,
-          userAccessToken,
-        });
-        const cloudResultContent = (cloudResult?.content ?? []) as ToolCallContent[];
-
-        // Format the cloud result to MCPToolCallResult format
-        // Process content blocks (upload images, etc.)
-        const newContent =
-          cloudResult?.isError || !ctx.fileService
-            ? cloudResultContent
-            : // FIXME: the type assertion here is a temporary solution, need to remove it after refactoring
-              await processContentBlocks(cloudResultContent, ctx.fileService);
-
-        // Convert content blocks to string
-        const content = contentBlocksToString(newContent);
-        const state = { ...cloudResult, content: newContent };
-
-        if (cloudResult?.isError) {
-          return { content, state, success: true };
-        }
-
-        return { content, state, success: true };
-      } catch (error) {
-        log('Error calling cloud MCP endpoint: %O', error);
-
-        // Re-throw TRPCError as-is
-        if (error instanceof TRPCError) {
-          throw error;
-        }
-
-        throw new TRPCError({
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'Failed to call cloud MCP endpoint',
-        });
-      }
-    }),
-
   // ============================== Assistant Market ==============================
   getAssistantCategories: marketProcedure
     .input(

package/src/server/routers/tools/_helpers/index.ts

@@ -0,0 +1 @@
+export * from './scheduleToolCallReport';

package/src/server/routers/tools/_helpers/scheduleToolCallReport.ts

@@ -0,0 +1,113 @@
+import { CURRENT_VERSION } from '@lobechat/const';
+import { type CallReportRequest } from '@lobehub/market-types';
+import { after } from 'next/server';
+
+import { DiscoverService } from '@/server/services/discover';
+
+/**
+ * Calculate byte size of object
+ */
+const calculateObjectSizeBytes = (obj: unknown): number => {
+  try {
+    const jsonString = JSON.stringify(obj);
+    return new TextEncoder().encode(jsonString).length;
+  } catch {
+    return 0;
+  }
+};
+
+export interface ToolCallReportMeta {
+  customPluginInfo?: {
+    avatar?: string;
+    description?: string;
+    name?: string;
+  };
+  isCustomPlugin?: boolean;
+  sessionId?: string;
+  version?: string;
+}
+
+export interface ScheduleToolCallReportParams {
+  /** Error code if call failed */
+  errorCode?: string;
+  /** Error message if call failed */
+  errorMessage?: string;
+  /** Plugin/tool identifier */
+  identifier: string;
+  /** Market access token for reporting */
+  marketAccessToken?: string;
+  /** MCP connection type */
+  mcpType: string;
+  /** Metadata for reporting */
+  meta?: ToolCallReportMeta;
+  /** Request payload for size calculation */
+  requestPayload: unknown;
+  /** Result for size calculation */
+  result?: unknown;
+  /** Start time of the call */
+  startTime: number;
+  /** Whether the call was successful */
+  success: boolean;
+  /** Whether telemetry is enabled */
+  telemetryEnabled: boolean;
+  /** Tool/method name */
+  toolName: string;
+}
+
+/**
+ * Schedule a tool call report to be sent after the response.
+ * Uses Next.js after() to avoid blocking the response.
+ */
+export function scheduleToolCallReport(params: ScheduleToolCallReportParams): void {
+  const {
+    telemetryEnabled,
+    marketAccessToken,
+    startTime,
+    success,
+    errorCode,
+    errorMessage,
+    result,
+    meta,
+    identifier,
+    toolName,
+    mcpType,
+    requestPayload,
+  } = params;
+
+  // Only report when telemetry is enabled and marketAccessToken exists
+  if (!telemetryEnabled || !marketAccessToken) return;
+
+  // Use Next.js after() to report after response is sent
+  after(async () => {
+    try {
+      const callDurationMs = Date.now() - startTime;
+      const requestSizeBytes = calculateObjectSizeBytes(requestPayload);
+      const responseSizeBytes = success && result ? calculateObjectSizeBytes(result) : 0;
+
+      const reportData: CallReportRequest = {
+        callDurationMs,
+        customPluginInfo: meta?.customPluginInfo,
+        errorCode,
+        errorMessage,
+        identifier,
+        isCustomPlugin: meta?.isCustomPlugin,
+        metadata: {
+          appVersion: CURRENT_VERSION,
+          mcpType,
+        },
+        methodName: toolName,
+        methodType: 'tool',
+        requestSizeBytes,
+        responseSizeBytes,
+        sessionId: meta?.sessionId,
+        success,
+        version: meta?.version || 'unknown',
+      };
+
+      const discoverService = new DiscoverService({ accessToken: marketAccessToken });
+      await discoverService.reportCall(reportData);
+    } catch (reportError) {
+      console.error('Failed to report tool call: %O', reportError);
+    }
+  });
+}

package/src/server/routers/tools/index.ts

@@ -1,14 +1,14 @@
 import { publicProcedure, router } from '@/libs/trpc/lambda';
 
-import { codeInterpreterRouter } from './codeInterpreter';
 import { klavisRouter } from './klavis';
+import { marketRouter } from './market';
 import { mcpRouter } from './mcp';
 import { searchRouter } from './search';
 
 export const toolsRouter = router({
-  codeInterpreter: codeInterpreterRouter,
   healthcheck: publicProcedure.query(() => "i'm live!"),
   klavis: klavisRouter,
+  market: marketRouter,
   mcp: mcpRouter,
   search: searchRouter,
 });