@lobehub/lobehub 2.0.0-next.337 → 2.0.0-next.339

package/packages/model-runtime/src/providers/moonshot/index.ts

@@ -21,7 +21,7 @@ export const params = {
       const filteredMessages = messages.map((message: any) => {
         let normalizedMessage = message;
 
-        // 为 assistant 空消息添加一个空格 (#8418)
+        // Add a space for empty assistant messages (#8418)
         if (message.role === 'assistant' && (!message.content || message.content === '')) {
           normalizedMessage = { ...normalizedMessage, content: ' ' };
         }

package/packages/model-runtime/src/providers/openai/index.ts

@@ -16,10 +16,10 @@ export interface OpenAIModelCard {
 const prunePrefixes = ['o1', 'o3', 'o4', 'codex', 'computer-use', 'gpt-5'];
 const oaiSearchContextSize = process.env.OPENAI_SEARCH_CONTEXT_SIZE; // low, medium, high
 const enableServiceTierFlex = process.env.OPENAI_SERVICE_TIER_FLEX === '1';
-const flexSupportedModels = ['gpt-5', 'o3', 'o4-mini']; // Flex 处理仅适用于这些模型
+const flexSupportedModels = ['gpt-5', 'o3', 'o4-mini']; // Flex tier is only available for these models
 
 const supportsFlexTier = (model: string) => {
-  // 排除 o3-mini，其不支持 Flex 处理
+  // Exclude o3-mini, which does not support Flex tier
   if (model.startsWith('o3-mini')) {
     return false;
   }
@@ -74,7 +74,7 @@ export const params = {
     const modelsPage = (await client.models.list()) as any;
     const modelList: OpenAIModelCard[] = modelsPage.data;
 
-    // 自动检测模型提供商并选择相应配置
+    // Automatically detect model provider and select corresponding configuration
     return processMultiProviderModelList(modelList, 'openai');
   },
   provider: ModelProvider.OpenAI,

package/packages/types/src/discover/index.ts

@@ -10,7 +10,7 @@ export * from './plugins';
 export * from './providers';
 
 export enum DiscoverTab {
-  Assistants = 'assistant',
+  Assistants = 'agent',
   GroupAgents = 'group_agent',
   Home = 'home',
   Mcp = 'mcp',

package/scripts/electronWorkflow/modifiers/dynamicToStatic.mts

@@ -0,0 +1,273 @@
+/* eslint-disable no-undef */
+import { Lang, parse } from '@ast-grep/napi';
+import path from 'node:path';
+
+import { invariant, isDirectRun, runStandalone, updateFile } from './utils.mjs';
+
+interface ImportInfo {
+  defaultImport?: string;
+  namedImports: string[];
+}
+
+interface DynamicElementInfo {
+  componentName: string;
+  end: number;
+  importPath: string;
+  isNamedExport: boolean;
+  namedExport?: string;
+  start: number;
+}
+
+const toPascalCase = (str: string): string => {
+  return str
+    .split(/[_-]/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('');
+};
+
+const generateComponentName = (
+  importPath: string,
+  namedExport?: string,
+  existingNames: Set<string> = new Set(),
+): string => {
+  if (namedExport) {
+    let name = namedExport;
+    let counter = 1;
+    while (existingNames.has(name)) {
+      name = `${namedExport}${counter++}`;
+    }
+    return name;
+  }
+
+  const segments = importPath
+    .split('/')
+    .filter((s) => s && !s.startsWith('.'))
+    .map((s) => s.replace(/^\((.+)\)$/, '$1').replace(/^\[(.+)]$/, '$1'));
+
+  const meaningfulSegments = segments.slice(-3).filter(Boolean);
+
+  let baseName =
+    meaningfulSegments.length > 0
+      ? meaningfulSegments.map((s) => toPascalCase(s)).join('') + 'Page'
+      : 'Page';
+
+  let name = baseName;
+  let counter = 1;
+  while (existingNames.has(name)) {
+    name = `${baseName}${counter++}`;
+  }
+
+  return name;
+};
+
+const extractDynamicElements = (code: string): DynamicElementInfo[] => {
+  const ast = parse(Lang.Tsx, code);
+  const root = ast.root();
+
+  const results: DynamicElementInfo[] = [];
+  const existingNames = new Set<string>();
+
+  const dynamicCalls = root.findAll({
+    rule: {
+      pattern: 'dynamicElement($IMPORT_FN, $DEBUG_ID)',
+    },
+  });
+
+  for (const call of dynamicCalls) {
+    const range = call.range();
+    const text = call.text();
+
+    const importMatch = text.match(/import\s*\(\s*["']([^"']+)["']\s*\)/);
+    invariant(
+      importMatch,
+      `[convertDynamicToStatic] Failed to extract import path from dynamicElement call: ${text.slice(0, 100)}`,
+    );
+
+    const importPath = importMatch![1];
+
+    const thenMatch = text.match(/\.then\s*\(\s*\(\s*(\w+)\s*\)\s*=>\s*\1\.(\w+)\s*\)/);
+    const namedExport = thenMatch ? thenMatch[2] : undefined;
+
+    const componentName = generateComponentName(importPath, namedExport, existingNames);
+    existingNames.add(componentName);
+
+    results.push({
+      componentName,
+      end: range.end.index,
+      importPath,
+      isNamedExport: !!namedExport,
+      namedExport,
+      start: range.start.index,
+    });
+  }
+
+  return results;
+};
+
+const buildImportMap = (elements: DynamicElementInfo[]): Map<string, ImportInfo> => {
+  const importMap = new Map<string, ImportInfo>();
+
+  for (const el of elements) {
+    const existing = importMap.get(el.importPath) || { namedImports: [] };
+
+    if (el.isNamedExport && el.namedExport) {
+      if (!existing.namedImports.includes(el.namedExport)) {
+        existing.namedImports.push(el.namedExport);
+      }
+    } else {
+      existing.defaultImport = el.componentName;
+    }
+
+    importMap.set(el.importPath, existing);
+  }
+
+  return importMap;
+};
+
+const generateImportStatements = (importMap: Map<string, ImportInfo>): string => {
+  const statements: string[] = [];
+
+  const sortedPaths = [...importMap.keys()].sort();
+
+  for (const importPath of sortedPaths) {
+    const info = importMap.get(importPath)!;
+    const parts: string[] = [];
+
+    if (info.defaultImport) {
+      parts.push(info.defaultImport);
+    }
+
+    if (info.namedImports.length > 0) {
+      parts.push(`{ ${info.namedImports.join(', ')} }`);
+    }
+
+    if (parts.length > 0) {
+      statements.push(`import ${parts.join(', ')} from '${importPath}';`);
+    }
+  }
+
+  return statements.join('\n');
+};
+
+const findImportInsertPosition = (code: string): number => {
+  const ast = parse(Lang.Tsx, code);
+  const root = ast.root();
+
+  const imports = root.findAll({
+    rule: {
+      kind: 'import_statement',
+    },
+  });
+
+  invariant(imports.length > 0, '[convertDynamicToStatic] No import statements found in file');
+
+  const lastImport = imports.at(-1)!;
+  return lastImport.range().end.index;
+};
+
+const removeDynamicElementImport = (code: string): string => {
+  const ast = parse(Lang.Tsx, code);
+  const root = ast.root();
+
+  const utilsRouterImport = root.find({
+    rule: {
+      kind: 'import_statement',
+      pattern: "import { $$$IMPORTS } from '@/utils/router'",
+    },
+  });
+
+  if (!utilsRouterImport) {
+    return code;
+  }
+
+  const importText = utilsRouterImport.text();
+
+  if (!importText.includes('dynamicElement')) {
+    return code;
+  }
+
+  const importSpecifiers = utilsRouterImport.findAll({
+    rule: {
+      kind: 'import_specifier',
+    },
+  });
+
+  const specifiersToKeep = importSpecifiers
+    .map((spec) => spec.text())
+    .filter((text) => !text.includes('dynamicElement'));
+
+  if (specifiersToKeep.length === 0) {
+    const range = utilsRouterImport.range();
+    let endIndex = range.end.index;
+    if (code[endIndex] === '\n') {
+      endIndex++;
+    }
+    return code.slice(0, range.start.index) + code.slice(endIndex);
+  }
+
+  const newImport = `import { ${specifiersToKeep.join(', ')} } from '@/utils/router';`;
+  const range = utilsRouterImport.range();
+  return code.slice(0, range.start.index) + newImport + code.slice(range.end.index);
+};
+
+export const convertDynamicToStatic = async (TEMP_DIR: string) => {
+  const routerConfigPath = path.join(
+    TEMP_DIR,
+    'src/app/[variants]/router/desktopRouter.config.tsx',
+  );
+
+  console.log('  Processing dynamicElement → static imports...');
+
+  await updateFile({
+    assertAfter: (code) => {
+      const noDynamicElement = !/dynamicElement\s*\(/.test(code);
+      const hasStaticImports = /^import .+ from ["']\.\.\/\(main\)/m.test(code);
+      return noDynamicElement && hasStaticImports;
+    },
+    filePath: routerConfigPath,
+    name: 'convertDynamicToStatic',
+    transformer: (code) => {
+      const elements = extractDynamicElements(code);
+
+      invariant(
+        elements.length > 0,
+        '[convertDynamicToStatic] No dynamicElement calls found in desktopRouter.config.tsx',
+      );
+
+      console.log(`    Found ${elements.length} dynamicElement calls`);
+
+      const importMap = buildImportMap(elements);
+      const importStatements = generateImportStatements(importMap);
+
+      const edits: Array<{ end: number; start: number; text: string }> = [];
+
+      for (const el of elements) {
+        edits.push({
+          end: el.end,
+          start: el.start,
+          text: `<${el.componentName} />`,
+        });
+      }
+
+      edits.sort((a, b) => b.start - a.start);
+
+      let result = code;
+      for (const edit of edits) {
+        result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+      }
+
+      const insertPos = findImportInsertPosition(result);
+      result = result.slice(0, insertPos) + '\n' + importStatements + result.slice(insertPos);
+
+      result = removeDynamicElementImport(result);
+
+      return result;
+    },
+  });
+};
+
+if (isDirectRun(import.meta.url)) {
+  await runStandalone('convertDynamicToStatic', convertDynamicToStatic, [
+    { lang: Lang.Tsx, path: 'src/app/[variants]/router/desktopRouter.config.tsx' },
+  ]);
+}

package/scripts/electronWorkflow/modifiers/index.mts

@@ -3,14 +3,24 @@ import path from 'node:path';
 
 import { modifyAppCode } from './appCode.mjs';
 import { cleanUpCode } from './cleanUp.mjs';
+import { convertDynamicToStatic } from './dynamicToStatic.mjs';
+import { convertNextDynamicToStatic } from './nextDynamicToStatic.mjs';
 import { modifyNextConfig } from './nextConfig.mjs';
+import { removeSuspenseFromConversation } from './removeSuspense.mjs';
 import { modifyRoutes } from './routes.mjs';
+import { convertSettingsContentToStatic } from './settingsContentToStatic.mjs';
 import { modifyStaticExport } from './staticExport.mjs';
 import { isDirectRun, runStandalone } from './utils.mjs';
+import { wrapChildrenWithClientOnly } from './wrapChildrenWithClientOnly.mjs';
 
 export const modifySourceForElectron = async (TEMP_DIR: string) => {
   await modifyNextConfig(TEMP_DIR);
   await modifyAppCode(TEMP_DIR);
+  await wrapChildrenWithClientOnly(TEMP_DIR);
+  await convertDynamicToStatic(TEMP_DIR);
+  await convertNextDynamicToStatic(TEMP_DIR);
+  await convertSettingsContentToStatic(TEMP_DIR);
+  await removeSuspenseFromConversation(TEMP_DIR);
   await modifyRoutes(TEMP_DIR);
   await modifyStaticExport(TEMP_DIR);
   await cleanUpCode(TEMP_DIR);

package/scripts/electronWorkflow/modifiers/nextConfig.mts

@@ -1,3 +1,4 @@
+/* eslint-disable no-undef */
 import { Lang, parse } from '@ast-grep/napi';
 import fs from 'fs-extra';
 import path from 'node:path';

package/scripts/electronWorkflow/modifiers/nextDynamicToStatic.mts

@@ -0,0 +1,233 @@
+/* eslint-disable no-undef */
+import { Lang, parse } from '@ast-grep/napi';
+import { glob } from 'glob';
+import fs from 'fs-extra';
+import path from 'node:path';
+
+import { invariant, isDirectRun, runStandalone } from './utils.mjs';
+
+interface DynamicImportInfo {
+  componentName: string;
+  end: number;
+  importPath: string;
+  start: number;
+}
+
+const extractDynamicImports = (code: string): DynamicImportInfo[] => {
+  const ast = parse(Lang.Tsx, code);
+  const root = ast.root();
+
+  const results: DynamicImportInfo[] = [];
+
+  const dynamicCalls = root.findAll({
+    rule: {
+      pattern: 'const $NAME = dynamic(() => import($PATH))',
+    },
+  });
+
+  for (const call of dynamicCalls) {
+    const range = call.range();
+    const text = call.text();
+
+    const nameMatch = text.match(/const\s+(\w+)\s*=/);
+    invariant(
+      nameMatch,
+      `[convertNextDynamicToStatic] Failed to extract component name from dynamic call: ${text.slice(0, 100)}`,
+    );
+
+    const importMatch = text.match(/import\s*\(\s*["']([^"']+)["']\s*\)/);
+    invariant(
+      importMatch,
+      `[convertNextDynamicToStatic] Failed to extract import path from dynamic call: ${text.slice(0, 100)}`,
+    );
+
+    results.push({
+      componentName: nameMatch![1],
+      end: range.end.index,
+      importPath: importMatch![1],
+      start: range.start.index,
+    });
+  }
+
+  const dynamicCallsWithOptions = root.findAll({
+    rule: {
+      pattern: 'const $NAME = dynamic(() => import($PATH), $OPTIONS)',
+    },
+  });
+
+  for (const call of dynamicCallsWithOptions) {
+    const range = call.range();
+    const text = call.text();
+
+    const nameMatch = text.match(/const\s+(\w+)\s*=/);
+    invariant(
+      nameMatch,
+      `[convertNextDynamicToStatic] Failed to extract component name from dynamic call: ${text.slice(0, 100)}`,
+    );
+
+    const importMatch = text.match(/import\s*\(\s*["']([^"']+)["']\s*\)/);
+    invariant(
+      importMatch,
+      `[convertNextDynamicToStatic] Failed to extract import path from dynamic call: ${text.slice(0, 100)}`,
+    );
+
+    const alreadyExists = results.some(
+      (r) => r.componentName === nameMatch![1] && r.importPath === importMatch![1],
+    );
+    if (alreadyExists) continue;
+
+    results.push({
+      componentName: nameMatch![1],
+      end: range.end.index,
+      importPath: importMatch![1],
+      start: range.start.index,
+    });
+  }
+
+  return results;
+};
+
+const generateImportStatements = (imports: DynamicImportInfo[]): string => {
+  const uniqueImports = new Map<string, string>();
+
+  for (const imp of imports) {
+    if (!uniqueImports.has(imp.importPath)) {
+      uniqueImports.set(imp.importPath, imp.componentName);
+    }
+  }
+
+  const sortedPaths = [...uniqueImports.keys()].sort();
+
+  return sortedPaths
+    .map((importPath) => {
+      const componentName = uniqueImports.get(importPath)!;
+      return `import ${componentName} from '${importPath}';`;
+    })
+    .join('\n');
+};
+
+const findImportInsertPosition = (code: string, filePath: string): number => {
+  const ast = parse(Lang.Tsx, code);
+  const root = ast.root();
+
+  const imports = root.findAll({
+    rule: {
+      kind: 'import_statement',
+    },
+  });
+
+  invariant(
+    imports.length > 0,
+    `[convertNextDynamicToStatic] No import statements found in ${filePath}`,
+  );
+
+  const lastImport = imports.at(-1)!;
+  return lastImport.range().end.index;
+};
+
+const removeDynamicImport = (code: string): string => {
+  const patterns = [
+    /import dynamic from ["']@\/libs\/next\/dynamic["'];\n?/g,
+    /import dynamic from ["']next\/dynamic["'];\n?/g,
+  ];
+
+  let result = code;
+  for (const pattern of patterns) {
+    result = result.replace(pattern, '');
+  }
+
+  return result;
+};
+
+const removeUnusedLoadingImport = (code: string): string => {
+  const codeWithoutImport = code.replaceAll(/import Loading from ["'][^"']+["'];?\n?/g, '');
+  if (!/\bLoading\b/.test(codeWithoutImport)) {
+    return code.replaceAll(/import Loading from ["'][^"']+["'];?\n?/g, '');
+  }
+  return code;
+};
+
+const transformFile = (code: string, filePath: string): string => {
+  const imports = extractDynamicImports(code);
+
+  if (imports.length === 0) {
+    return code;
+  }
+
+  const importStatements = generateImportStatements(imports);
+
+  const edits: Array<{ end: number; start: number; text: string }> = [];
+
+  for (const imp of imports) {
+    edits.push({
+      end: imp.end,
+      start: imp.start,
+      text: '',
+    });
+  }
+
+  edits.sort((a, b) => b.start - a.start);
+
+  let result = code;
+  for (const edit of edits) {
+    let endIndex = edit.end;
+    while (result[endIndex] === '\n' || result[endIndex] === '\r') {
+      endIndex++;
+    }
+    result = result.slice(0, edit.start) + result.slice(endIndex);
+  }
+
+  const insertPos = findImportInsertPosition(result, filePath);
+  if (importStatements) {
+    result = result.slice(0, insertPos) + '\n' + importStatements + result.slice(insertPos);
+  }
+
+  result = removeDynamicImport(result);
+  result = removeUnusedLoadingImport(result);
+
+  result = result.replaceAll(/\n{3,}/g, '\n\n');
+
+  return result;
+};
+
+export const convertNextDynamicToStatic = async (TEMP_DIR: string) => {
+  const appDirs = [
+    { dir: path.join(TEMP_DIR, 'src/app/(variants)'), label: 'src/app/(variants)' },
+    { dir: path.join(TEMP_DIR, 'src/app/[variants]'), label: 'src/app/[variants]' },
+  ];
+
+  console.log('  Processing next/dynamic → static imports...');
+
+  let processedCount = 0;
+
+  for (const { dir, label } of appDirs) {
+    if (!(await fs.pathExists(dir))) {
+      continue;
+    }
+
+    const files = await glob('**/*.tsx', { cwd: dir });
+
+    for (const file of files) {
+      const filePath = path.join(dir, file);
+      const code = await fs.readFile(filePath, 'utf8');
+
+      if (!code.includes('dynamic(')) {
+        continue;
+      }
+
+      const transformed = transformFile(code, `${label}/${file}`);
+
+      if (transformed !== code) {
+        await fs.writeFile(filePath, transformed);
+        processedCount++;
+        console.log(`    Transformed: ${label}/${file}`);
+      }
+    }
+  }
+
+  console.log(`    Processed ${processedCount} files with dynamic imports`);
+};
+
+if (isDirectRun(import.meta.url)) {
+  await runStandalone('convertNextDynamicToStatic', convertNextDynamicToStatic, []);
+}

package/scripts/electronWorkflow/modifiers/removeSuspense.mts

@@ -0,0 +1,124 @@
+import { Lang, parse } from '@ast-grep/napi';
+import path from 'node:path';
+
+import { invariant, isDirectRun, runStandalone, updateFile } from './utils.mjs';
+
+const removeSuspenseWrapper = (code: string): string => {
+  const ast = parse(Lang.Tsx, code);
+  const root = ast.root();
+
+  const suspenseElements = root.findAll({
+    rule: {
+      has: {
+        has: {
+          kind: 'identifier',
+          regex: '^Suspense$',
+        },
+        kind: 'jsx_opening_element',
+      },
+      kind: 'jsx_element',
+    },
+  });
+
+  if (suspenseElements.length === 0) {
+    return code;
+  }
+
+  const edits: Array<{ end: number; start: number; text: string }> = [];
+
+  for (const suspense of suspenseElements) {
+    const range = suspense.range();
+
+    const children = suspense.children();
+    let childrenText = '';
+
+    for (const child of children) {
+      const kind = child.kind();
+      if (kind === 'jsx_element' || kind === 'jsx_self_closing_element' || kind === 'jsx_fragment') {
+        childrenText = child.text();
+        break;
+      }
+    }
+
+    if (childrenText) {
+      edits.push({
+        end: range.end.index,
+        start: range.start.index,
+        text: childrenText,
+      });
+    }
+  }
+
+  edits.sort((a, b) => b.start - a.start);
+
+  let result = code;
+  for (const edit of edits) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+
+  return result;
+};
+
+const removeUnusedImports = (code: string): string => {
+  let result = code;
+
+  if (!result.includes('<Suspense')) {
+    result = result.replaceAll(/,?\s*Suspense\s*,?/g, (match) => {
+      if (match.startsWith(',') && match.endsWith(',')) {
+        return ',';
+      }
+      return '';
+    });
+
+    result = result.replaceAll(/{\s*,/g, '{');
+    result = result.replaceAll(/,\s*}/g, '}');
+    result = result.replaceAll(/{\s*}/g, '');
+    result = result.replaceAll(/import\s+{\s*}\s+from\s+["'][^"']+["'];\n?/g, '');
+  }
+
+  if (!result.includes('<Loading') && !result.includes('Loading />')) {
+    result = result.replaceAll(
+      /import Loading from ["']@\/components\/Loading\/BrandTextLoading["'];\n?/g,
+      '',
+    );
+  }
+
+  result = result.replaceAll(/\n{3,}/g, '\n\n');
+
+  return result;
+};
+
+export const removeSuspenseFromConversation = async (TEMP_DIR: string) => {
+  const filePath = path.join(
+    TEMP_DIR,
+    'src/app/[variants]/(main)/agent/features/Conversation/index.tsx',
+  );
+
+  console.log('  Removing Suspense from Conversation/index.tsx...');
+
+  await updateFile({
+    assertAfter: (code) => {
+      const noSuspenseElement = !/<Suspense/.test(code);
+      return noSuspenseElement;
+    },
+    filePath,
+    name: 'removeSuspenseFromConversation',
+    transformer: (code) => {
+      invariant(
+        /<Suspense/.test(code),
+        '[removeSuspenseFromConversation] No Suspense element found in Conversation/index.tsx',
+      );
+
+      let result = removeSuspenseWrapper(code);
+      result = removeUnusedImports(result);
+
+      return result;
+    },
+  });
+};
+
+if (isDirectRun(import.meta.url)) {
+  await runStandalone('removeSuspenseFromConversation', removeSuspenseFromConversation, [
+    { lang: Lang.Tsx, path: 'src/app/[variants]/(main)/agent/features/Conversation/index.tsx' },
+  ]);
+}