@lobehub/chat 1.0.0 → 1.0.2

package/src/app/api/plugin/gateway/settings.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+
+import { parserPluginSettings } from './settings';
+
+describe('parserPluginSettings', () => {
+  it('should return an empty object when input is undefined', () => {
+    expect(parserPluginSettings()).toEqual({});
+  });
+
+  it('should return an empty object when input is an empty string', () => {
+    expect(parserPluginSettings('')).toEqual({});
+  });
+
+  it('should parse plugin settings from a well-formed string', () => {
+    const input = 'plugin1:key1=value1;key2=value2,plugin2:key3=value3';
+    const expected = {
+      plugin1: { key1: 'value1', key2: 'value2' },
+      plugin2: { key3: 'value3' },
+    };
+    expect(parserPluginSettings(input)).toEqual(expected);
+  });
+
+  it('should handle strings with Chinese commas', () => {
+    const input = 'plugin1:key1=value1;key2=value2，plugin2:key3=value3';
+    const expected = {
+      plugin1: { key1: 'value1', key2: 'value2' },
+      plugin2: { key3: 'value3' },
+    };
+    expect(parserPluginSettings(input)).toEqual(expected);
+  });
+
+  it('should ignore empty segments', () => {
+    const input = 'plugin1:key1=value1;key2=value2,,,plugin2:key3=value3';
+    const expected = {
+      plugin1: { key1: 'value1', key2: 'value2' },
+      plugin2: { key3: 'value3' },
+    };
+    expect(parserPluginSettings(input)).toEqual(expected);
+  });
+
+  it('should merge settings for the same pluginId', () => {
+    const input = 'plugin1:key1=value1;key2=value2,plugin1:key3=value3;key4=value4';
+    const expected = {
+      plugin1: { key1: 'value1', key2: 'value2', key3: 'value3', key4: 'value4' },
+    };
+    expect(parserPluginSettings(input)).toEqual(expected);
+  });
+
+  it('should override previous values if the same key appears again for the same pluginId', () => {
+    const input = 'plugin1:key1=value1;key2=value2,plugin1:key2=newValue2;key3=value3';
+    const expected = {
+      plugin1: { key1: 'value1', key2: 'newValue2', key3: 'value3' },
+    };
+    expect(parserPluginSettings(input)).toEqual(expected);
+  });
+
+  describe('error senses', () => {
+    it('should ignore settings with incorrect key-value format', () => {
+      const input = 'plugin1:key1=value1;incorrectFormat,plugin2:key2=value2';
+      const expected = {
+        plugin1: { key1: 'value1' },
+        plugin2: { key2: 'value2' },
+      };
+      expect(parserPluginSettings(input)).toEqual(expected);
+    });
+
+    it('should handle extra separators gracefully', () => {
+      const input = 'plugin1:key1=value1==value1.1;key2=value2;,plugin2:key3=value3';
+      const expected = {
+        plugin1: { key1: 'value1', key2: 'value2' },
+        plugin2: { key3: 'value3' },
+      };
+      expect(parserPluginSettings(input)).toEqual(expected);
+    });
+
+    it('should ignore settings with empty keys or values', () => {
+      const input = 'plugin1:=value1;key2=,plugin2:key3=value3';
+      const expected = {
+        plugin2: { key3: 'value3' },
+      };
+
+      expect(parserPluginSettings(input)).toEqual(expected);
+    });
+
+    it('should ignore leading and trailing whitespace in keys and values', () => {
+      const input = ' plugin1 : key1 = value1 ; key2 =  value2 , plugin2 : key3=value3 ';
+      const expected = {
+        plugin1: { key1: 'value1', key2: 'value2' },
+        plugin2: { key3: 'value3' },
+      };
+      expect(parserPluginSettings(input)).toEqual(expected);
+    });
+
+    it('should handle special characters in keys and values', () => {
+      const input = 'plugin1:key1=value1+special;key2=value2#special,plugin2:key3=value3/special';
+      const expected = {
+        plugin1: { key1: 'value1+special', key2: 'value2#special' },
+        plugin2: { key3: 'value3/special' },
+      };
+      expect(parserPluginSettings(input)).toEqual(expected);
+    });
+
+    // ... (additional test cases as needed)
+  });
+});

package/src/app/api/plugin/gateway/settings.ts

@@ -0,0 +1,29 @@
+export const parserPluginSettings = (
+  settingsStr?: string,
+): Record<string, Record<string, string>> => {
+  if (!settingsStr) return {};
+
+  const settings = new Map();
+
+  const array = settingsStr.split(/[,，]/).filter(Boolean);
+
+  for (const item of array) {
+    const [id, pluginSettingsStr] = item.split(':');
+    if (!id) continue;
+
+    const pluginSettingItems = pluginSettingsStr.split(';');
+
+    const cleanId = id.trim();
+
+    for (const item of pluginSettingItems) {
+      const [key, value] = item.split('=');
+      if (!key || !value) continue;
+      const cleanKey = key.trim();
+      const cleanValue = value.trim();
+
+      settings.set(cleanId, { ...settings.get(cleanId), [cleanKey]: cleanValue });
+    }
+  }
+
+  return Object.fromEntries(settings.entries());
+};

package/src/app/api/plugin/store/Store.test.ts

@@ -0,0 +1,26 @@
+// @vitest-environment node
+import { describe, expect, it, vi } from 'vitest';
+
+import { PluginStore } from './Store';
+
+const baseURL = 'https://chat-plugins.lobehub.com';
+
+describe('PluginStore', () => {
+  it('should return the default index URL when no language is provided', () => {
+    const pluginStore = new PluginStore();
+    const url = pluginStore.getPluginIndexUrl();
+    expect(url).toBe(baseURL);
+  });
+
+  it('should return the index URL for a supported language', () => {
+    const pluginStore = new PluginStore();
+    const url = pluginStore.getPluginIndexUrl('en-US');
+    expect(url).toBe(baseURL);
+  });
+
+  it('should return the base URL if the provided language is not supported', () => {
+    const pluginStore = new PluginStore();
+    const url = pluginStore.getPluginIndexUrl('fr-FR');
+    expect(url).toBe(`${baseURL}/index.fr-FR.json`);
+  });
+});

package/src/app/api/plugin/store/Store.ts

@@ -0,0 +1,19 @@
+import urlJoin from 'url-join';
+
+import { appEnv } from '@/config/app';
+import { DEFAULT_LANG, isLocaleNotSupport } from '@/const/locale';
+import { Locales, normalizeLocale } from '@/locales/resources';
+
+export class PluginStore {
+  private readonly baseUrl: string;
+
+  constructor(baseUrl?: string) {
+    this.baseUrl = baseUrl || appEnv.PLUGINS_INDEX_URL;
+  }
+
+  getPluginIndexUrl = (lang: Locales = DEFAULT_LANG) => {
+    if (isLocaleNotSupport(lang)) return this.baseUrl;
+
+    return urlJoin(this.baseUrl, `index.${normalizeLocale(lang)}.json`);
+  };
+}

package/src/app/api/plugin/store/route.ts

@@ -0,0 +1,23 @@
+import { DEFAULT_LANG } from '@/const/locale';
+
+import { PluginStore } from './Store';
+
+export const runtime = 'edge';
+
+export const revalidate = 43_200; // revalidate at almost every 12 hours
+
+export const GET = async (req: Request) => {
+  const locale = new URL(req.url).searchParams.get('locale');
+
+  const pluginStore = new PluginStore();
+
+  let res: Response;
+
+  res = await fetch(pluginStore.getPluginIndexUrl(locale as any));
+
+  if (res.status === 404) {
+    res = await fetch(pluginStore.getPluginIndexUrl(DEFAULT_LANG));
+  }
+
+  return res;
+};

package/src/app/api/proxy/route.ts

@@ -0,0 +1,34 @@
+import { isPrivate } from 'ip';
+import { NextResponse } from 'next/server';
+import dns from 'node:dns';
+import { promisify } from 'node:util';
+
+const lookupAsync = promisify(dns.lookup);
+
+export const runtime = 'nodejs';
+
+/**
+ * just for a proxy
+ */
+export const POST = async (req: Request) => {
+  const url = new URL(await req.text());
+  let address;
+
+  try {
+    const lookupResult = await lookupAsync(url.hostname);
+    address = lookupResult.address;
+  } catch (err) {
+    console.error(`${url.hostname} DNS parser error:`, err);
+
+    return NextResponse.json({ error: 'DNS parser error' }, { status: 504 });
+  }
+
+  const isInternalHost = isPrivate(address);
+
+  if (isInternalHost)
+    return NextResponse.json({ error: 'Not support internal host proxy' }, { status: 400 });
+
+  const res = await fetch(url.toString());
+
+  return new Response(res.body, { headers: res.headers });
+};

package/src/app/api/text-to-image/[provider]/route.ts

@@ -0,0 +1,61 @@
+import { NextResponse } from 'next/server';
+
+import { getPreferredRegion } from '@/app/api/config';
+import { createErrorResponse } from '@/app/api/errorResponse';
+import { ChatCompletionErrorPayload } from '@/libs/agent-runtime';
+import { TextToImagePayload } from '@/libs/agent-runtime/types';
+import { ChatErrorType } from '@/types/fetch';
+
+import { initAgentRuntimeWithUserPayload } from '../../chat/agentRuntime';
+import { checkAuth } from '../../middleware/auth';
+
+export const runtime = 'edge';
+
+export const preferredRegion = getPreferredRegion();
+
+// return NextResponse.json(
+//   {
+//     body: {
+//       endpoint: 'https://ai****ix.com/v1',
+//       error: {
+//         code: 'content_policy_violation',
+//         message:
+//           'Your request was rejected as a result of our safety system. Image descriptions generated from your prompt may contain text that is not allowed by our safety system. If you believe this was done in error, your request may succeed if retried, or by adjusting your prompt.',
+//         param: null,
+//         type: 'invalid_request_error',
+//       },
+//       provider: 'openai',
+//     },
+//     errorType: 'OpenAIBizError',
+//   },
+//   { status: 400 },
+// );
+
+export const POST = checkAuth(async (req: Request, { params, jwtPayload }) => {
+  const { provider } = params;
+
+  try {
+    // ============  1. init chat model   ============ //
+    const agentRuntime = await initAgentRuntimeWithUserPayload(provider, jwtPayload);
+
+    // ============  2. create chat completion   ============ //
+
+    const data = (await req.json()) as TextToImagePayload;
+
+    const images = await agentRuntime.textToImage(data);
+
+    return NextResponse.json(images);
+  } catch (e) {
+    const {
+      errorType = ChatErrorType.InternalServerError,
+      error: errorContent,
+      ...res
+    } = e as ChatCompletionErrorPayload;
+
+    const error = errorContent || e;
+    // track the error at server side
+    console.error(`Route: [${provider}] ${errorType}:`, error);
+
+    return createErrorResponse(errorType, { error, ...res, provider });
+  }
+});

package/src/app/api/trace/route.ts

@@ -0,0 +1,40 @@
+import { TraceEventType } from '@/const/trace';
+import { TraceClient } from '@/libs/traces';
+import { TraceEventBasePayload, TraceEventPayloads } from '@/types/trace';
+
+export const runtime = 'edge';
+
+export const POST = async (req: Request) => {
+  type RequestData = TraceEventPayloads & TraceEventBasePayload;
+  const data = (await req.json()) as RequestData;
+  const { traceId, eventType } = data;
+
+  const traceClient = new TraceClient();
+
+  const eventClient = traceClient.createEvent(traceId);
+
+  switch (eventType) {
+    case TraceEventType.ModifyMessage: {
+      eventClient?.modifyMessage(data);
+      break;
+    }
+
+    case TraceEventType.DeleteAndRegenerateMessage: {
+      eventClient?.deleteAndRegenerateMessage(data);
+      break;
+    }
+
+    case TraceEventType.RegenerateMessage: {
+      eventClient?.regenerateMessage(data);
+      break;
+    }
+
+    case TraceEventType.CopyMessage: {
+      eventClient?.copyMessage(data);
+      break;
+    }
+  }
+
+  await traceClient.shutdownAsync();
+  return new Response(undefined, { status: 201 });
+};

package/src/app/api/tts/edge-speech/route.ts

@@ -0,0 +1,9 @@
+import { EdgeSpeechPayload, EdgeSpeechTTS } from '@lobehub/tts';
+
+export const runtime = 'edge';
+
+export const POST = async (req: Request) => {
+  const payload = (await req.json()) as EdgeSpeechPayload;
+
+  return await EdgeSpeechTTS.createRequest({ payload });
+};

package/src/app/api/tts/microsoft-speech/route.ts

@@ -0,0 +1,9 @@
+import { MicrosoftSpeechPayload, MicrosoftSpeechTTS } from '@lobehub/tts';
+
+export const runtime = 'edge';
+
+export const POST = async (req: Request) => {
+  const payload = (await req.json()) as MicrosoftSpeechPayload;
+
+  return await MicrosoftSpeechTTS.createRequest({ payload });
+};

package/src/app/api/webhooks/clerk/__tests__/fixtures/createUser.json

@@ -0,0 +1,73 @@
+{
+  "backup_code_enabled": false,
+  "banned": false,
+  "create_organization_enabled": true,
+  "created_at": 1713709987911,
+  "delete_self_enabled": true,
+  "email_addresses": [
+    {
+      "created_at": 1713709977919,
+      "email_address": "arvinx@foxmail.com",
+      "id": "idn_2fPkD9X1lfzSn5lJVDGyochYq8k",
+      "linked_to": [],
+      "object": "email_address",
+      "reserved": false,
+      "updated_at": 1713709987951,
+      "verification": []
+    }
+  ],
+  "external_accounts": [
+    {
+      "approved_scopes": "read:user user:email",
+      "avatar_url": "https://avatars.githubusercontent.com/u/28616219?v=4",
+      "created_at": 1713709542104,
+      "email_address": "arvinx@foxmail.com",
+      "first_name": "Arvin",
+      "id": "eac_2fPjKROeJ1bBs8Uxa6RFMxKogTB",
+      "identification_id": "idn_2fPjyV3sqtQJZUbEzdK2y23a1bq",
+      "image_url": "https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2F2YXRhcnMuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3UvMjg2MTYyMTk/dj00IiwicyI6IkhCeHE5NmdlRk85ekRxMjJlR05EalUrbVFBbmVDZjRVQkpwNGYxcW5JajQifQ",
+      "label": null,
+      "last_name": "Xu",
+      "object": "external_account",
+      "provider": "oauth_github",
+      "provider_user_id": "28616219",
+      "public_metadata": {},
+      "updated_at": 1713709542104,
+      "username": "arvinxx",
+      "verification": {
+        "attempts": null,
+        "expire_at": 1713710140131,
+        "status": "verified",
+        "strategy": "oauth_github"
+      }
+    }
+  ],
+  "external_id": null,
+  "first_name": "Arvin",
+  "has_image": true,
+  "id": "user_2fPkELglwI48WpZVwwdAxBKBPK6",
+  "image_url": "https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvb2F1dGhfZ2l0aHViL2ltZ18yZlBrRU1adVpwdlpvZFBHcVREdHJnTzJJM3cifQ",
+  "last_active_at": 1713709987902,
+  "last_name": "Xu",
+  "last_sign_in_at": null,
+  "locked": false,
+  "lockout_expires_in_seconds": null,
+  "object": "user",
+  "passkeys": [],
+  "password_enabled": false,
+  "phone_numbers": [],
+  "primary_email_address_id": "idn_2fPkD9X1lfzSn5lJVDGyochYq8k",
+  "primary_phone_number_id": null,
+  "primary_web3_wallet_id": null,
+  "private_metadata": {},
+  "profile_image_url": "https://images.clerk.dev/oauth_github/img_2fPkEMZuZpvZodPGqTDtrgO2I3w",
+  "public_metadata": {},
+  "saml_accounts": [],
+  "totp_enabled": false,
+  "two_factor_enabled": false,
+  "unsafe_metadata": {},
+  "updated_at": 1713709987972,
+  "username": "arvinxx",
+  "verification_attempts_remaining": 100,
+  "web3_wallets": []
+}

package/src/app/api/webhooks/clerk/route.ts

@@ -0,0 +1,159 @@
+import { UserJSON } from '@clerk/backend';
+import { NextResponse } from 'next/server';
+
+import { authEnv } from '@/config/auth';
+import { isServerMode } from '@/const/version';
+import { UserModel } from '@/database/server/models/user';
+import { pino } from '@/libs/logger';
+
+import { validateRequest } from './validateRequest';
+
+if (authEnv.NEXT_PUBLIC_ENABLE_CLERK_AUTH && isServerMode && !authEnv.CLERK_WEBHOOK_SECRET) {
+  throw new Error('`CLERK_WEBHOOK_SECRET` environment variable is missing');
+}
+
+const createUser = async (id: string, params: UserJSON) => {
+  pino.info('creating user due to clerk webhook');
+
+  const userModel = new UserModel();
+
+  // Check if user already exists
+  const res = await userModel.findById(id);
+
+  // If user already exists, skip creating a new user
+  if (res)
+    return NextResponse.json(
+      { message: 'user not created due to user already existing in the database', success: false },
+      { status: 200 },
+    );
+
+  const email = params.email_addresses.find((e) => e.id === params.primary_email_address_id);
+  const phone = params.phone_numbers.find((e) => e.id === params.primary_phone_number_id);
+
+  await userModel.createUser({
+    avatar: params.image_url,
+    clerkCreatedAt: new Date(params.created_at),
+    email: email?.email_address,
+    firstName: params.first_name,
+    id,
+    lastName: params.last_name,
+    phone: phone?.phone_number,
+    username: params.username,
+  });
+
+  return NextResponse.json({ message: 'user created', success: true }, { status: 200 });
+};
+
+const deleteUser = async (id?: string) => {
+  if (id) {
+    pino.info('delete user due to clerk webhook');
+    const userModel = new UserModel();
+
+    await userModel.deleteUser(id);
+
+    return NextResponse.json({ message: 'user deleted' }, { status: 200 });
+  } else {
+    pino.warn('clerk sent a delete user request, but no user ID was included in the payload');
+    return NextResponse.json({ message: 'ok' }, { status: 200 });
+  }
+};
+
+const updateUser = async (id: string, params: UserJSON) => {
+  pino.info('updating user due to clerk webhook');
+
+  const userModel = new UserModel();
+
+  // Check if user already exists
+  const res = await userModel.findById(id);
+
+  // If user not exists, skip update the user
+  if (!res)
+    return NextResponse.json(
+      {
+        message: "user not updated due to the user don't existing in the database",
+        success: false,
+      },
+      { status: 200 },
+    );
+
+  const email = params.email_addresses.find((e) => e.id === params.primary_email_address_id);
+  const phone = params.phone_numbers.find((e) => e.id === params.primary_phone_number_id);
+
+  await userModel.updateUser(id, {
+    avatar: params.image_url,
+    email: email?.email_address,
+    firstName: params.first_name,
+    id,
+    lastName: params.last_name,
+    phone: phone?.phone_number,
+    username: params.username,
+  });
+
+  return NextResponse.json({ message: 'user updated', success: true }, { status: 200 });
+};
+
+export const POST = async (req: Request): Promise<NextResponse> => {
+  const payload = await validateRequest(req, authEnv.CLERK_WEBHOOK_SECRET!);
+
+  if (!payload) {
+    return NextResponse.json(
+      { error: 'webhook verification failed or payload was malformed' },
+      { status: 400 },
+    );
+  }
+
+  const { type, data } = payload;
+
+  pino.trace(`clerk webhook payload: ${{ data, type }}`);
+
+  switch (type) {
+    case 'user.created': {
+      return createUser(data.id, data);
+    }
+    case 'user.deleted': {
+      return deleteUser(data.id);
+    }
+    case 'user.updated': {
+      return updateUser(data.id, data);
+    }
+
+    default: {
+      pino.warn(
+        `${req.url} received event type "${type}", but no handler is defined for this type`,
+      );
+      return NextResponse.json({ error: `uncreognised payload type: ${type}` }, { status: 400 });
+    }
+    // case 'user.updated':
+    //   break;
+    // case 'session.created':
+    //   break;
+    // case 'session.ended':
+    //   break;
+    // case 'session.removed':
+    //   break;
+    // case 'session.revoked':
+    //   break;
+    // case 'email.created':
+    //   break;
+    // case 'sms.created':
+    //   break;
+    // case 'organization.created':
+    //   break;
+    // case 'organization.updated':
+    //   break;
+    // case 'organization.deleted':
+    //   break;
+    // case 'organizationMembership.created':
+    //   break;
+    // case 'organizationMembership.deleted':
+    //   break;
+    // case 'organizationMembership.updated':
+    //   break;
+    // case 'organizationInvitation.accepted':
+    //   break;
+    // case 'organizationInvitation.created':
+    //   break;
+    // case 'organizationInvitation.revoked':
+    //   break;
+  }
+};

package/src/app/api/webhooks/clerk/validateRequest.ts

@@ -0,0 +1,22 @@
+import { WebhookEvent } from '@clerk/nextjs/server';
+import { headers } from 'next/headers';
+import { Webhook } from 'svix';
+
+export const validateRequest = async (request: Request, secret: string) => {
+  const payloadString = await request.text();
+  const headerPayload = headers();
+
+  const svixHeaders = {
+    'svix-id': headerPayload.get('svix-id')!,
+    'svix-signature': headerPayload.get('svix-signature')!,
+    'svix-timestamp': headerPayload.get('svix-timestamp')!,
+  };
+  const wh = new Webhook(secret);
+
+  try {
+    return wh.verify(payloadString, svixHeaders) as WebhookEvent;
+  } catch {
+    console.error('incoming webhook failed verification');
+    return;
+  }
+};

package/src/app/error.tsx

@@ -0,0 +1,5 @@
+'use client';
+
+import dynamic from 'next/dynamic';
+
+export default dynamic(() => import('@/components/Error'));

package/src/app/global-error.tsx

@@ -0,0 +1,20 @@
+'use client';
+
+import Error from 'next/error';
+import { useLayoutEffect } from 'react';
+
+import { type ErrorType, sentryCaptureException } from '@/components/Error/sentryCaptureException';
+
+export default function GlobalError({ error }: { error: ErrorType; reset: () => void }) {
+  useLayoutEffect(() => {
+    sentryCaptureException(error);
+  }, [error]);
+
+  return (
+    <html>
+      <body>
+        <Error statusCode={undefined as any} />
+      </body>
+    </html>
+  );
+}