@lobehub/chat 1.82.0 → 1.82.1

package/src/features/Conversation/components/MarkdownElements/remarkPlugins/__snapshots__/createRemarkSelfClosingTagPlugin.test.ts.snap

@@ -0,0 +1,260 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`createRemarkSelfClosingTagPlugin > should handle tag within a list item and generate snapshot 1`] = `
+{
+  "children": [
+    {
+      "children": [
+        {
+          "checked": null,
+          "children": [
+            {
+              "children": [
+                {
+                  "position": {
+                    "end": {
+                      "column": 26,
+                      "line": 2,
+                      "offset": 26,
+                    },
+                    "start": {
+                      "column": 4,
+                      "line": 2,
+                      "offset": 4,
+                    },
+                  },
+                  "type": "text",
+                  "value": "文件名：飞机全书 一部明晰可见的历史.pdf",
+                },
+              ],
+              "position": {
+                "end": {
+                  "column": 26,
+                  "line": 2,
+                  "offset": 26,
+                },
+                "start": {
+                  "column": 4,
+                  "line": 2,
+                  "offset": 4,
+                },
+              },
+              "type": "paragraph",
+            },
+            {
+              "children": [
+                {
+                  "checked": null,
+                  "children": [
+                    {
+                      "children": [
+                        {
+                          "position": {
+                            "end": {
+                              "column": 10,
+                              "line": 3,
+                              "offset": 36,
+                            },
+                            "start": {
+                              "column": 6,
+                              "line": 3,
+                              "offset": 32,
+                            },
+                          },
+                          "type": "text",
+                          "value": "路径1：",
+                        },
+                        {
+                          "data": {
+                            "hName": "localFile",
+                            "hProperties": {
+                              "name": "飞机全书 一部明晰可见的历史.pdf",
+                              "path": "/Users/abc/Zotero/storage/ASBMAURK/飞机全书 一部明晰可见的历史.pdf",
+                            },
+                          },
+                          "type": "localFile",
+                        },
+                      ],
+                      "position": {
+                        "end": {
+                          "column": 110,
+                          "line": 3,
+                          "offset": 136,
+                        },
+                        "start": {
+                          "column": 6,
+                          "line": 3,
+                          "offset": 32,
+                        },
+                      },
+                      "type": "paragraph",
+                    },
+                  ],
+                  "position": {
+                    "end": {
+                      "column": 110,
+                      "line": 3,
+                      "offset": 136,
+                    },
+                    "start": {
+                      "column": 4,
+                      "line": 3,
+                      "offset": 30,
+                    },
+                  },
+                  "spread": false,
+                  "type": "listItem",
+                },
+                {
+                  "checked": null,
+                  "children": [
+                    {
+                      "children": [
+                        {
+                          "position": {
+                            "end": {
+                              "column": 56,
+                              "line": 4,
+                              "offset": 192,
+                            },
+                            "start": {
+                              "column": 6,
+                              "line": 4,
+                              "offset": 142,
+                            },
+                          },
+                          "type": "text",
+                          "value": "路径2：/Users/abc/Downloads/测试 PDF/飞机全书 一部明晰可见的历史.pdf",
+                        },
+                      ],
+                      "position": {
+                        "end": {
+                          "column": 56,
+                          "line": 4,
+                          "offset": 192,
+                        },
+                        "start": {
+                          "column": 6,
+                          "line": 4,
+                          "offset": 142,
+                        },
+                      },
+                      "type": "paragraph",
+                    },
+                  ],
+                  "position": {
+                    "end": {
+                      "column": 56,
+                      "line": 4,
+                      "offset": 192,
+                    },
+                    "start": {
+                      "column": 4,
+                      "line": 4,
+                      "offset": 140,
+                    },
+                  },
+                  "spread": false,
+                  "type": "listItem",
+                },
+              ],
+              "ordered": false,
+              "position": {
+                "end": {
+                  "column": 56,
+                  "line": 4,
+                  "offset": 192,
+                },
+                "start": {
+                  "column": 4,
+                  "line": 3,
+                  "offset": 30,
+                },
+              },
+              "spread": false,
+              "start": null,
+              "type": "list",
+            },
+          ],
+          "position": {
+            "end": {
+              "column": 56,
+              "line": 4,
+              "offset": 192,
+            },
+            "start": {
+              "column": 1,
+              "line": 2,
+              "offset": 1,
+            },
+          },
+          "spread": false,
+          "type": "listItem",
+        },
+      ],
+      "ordered": true,
+      "position": {
+        "end": {
+          "column": 56,
+          "line": 4,
+          "offset": 192,
+        },
+        "start": {
+          "column": 1,
+          "line": 2,
+          "offset": 1,
+        },
+      },
+      "spread": false,
+      "start": 1,
+      "type": "list",
+    },
+    {
+      "children": [
+        {
+          "position": {
+            "end": {
+              "column": 75,
+              "line": 6,
+              "offset": 268,
+            },
+            "start": {
+              "column": 1,
+              "line": 6,
+              "offset": 194,
+            },
+          },
+          "type": "text",
+          "value": "这是一本 PDF 格式的书，并且在你的 Zotero 和 Downloads 文件夹里都能找到。如果需要进一步操作，比如阅读或者提取内容，可以告诉我",
+        },
+      ],
+      "position": {
+        "end": {
+          "column": 75,
+          "line": 6,
+          "offset": 268,
+        },
+        "start": {
+          "column": 1,
+          "line": 6,
+          "offset": 194,
+        },
+      },
+      "type": "paragraph",
+    },
+  ],
+  "position": {
+    "end": {
+      "column": 1,
+      "line": 7,
+      "offset": 269,
+    },
+    "start": {
+      "column": 1,
+      "line": 1,
+      "offset": 0,
+    },
+  },
+  "type": "root",
+}
+`;

package/src/features/Conversation/components/MarkdownElements/remarkPlugins/createRemarkSelfClosingTagPlugin.test.ts

@@ -0,0 +1,204 @@
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+import { describe, expect, it } from 'vitest';
+
+import { createRemarkSelfClosingTagPlugin } from './createRemarkSelfClosingTagPlugin';
+
+// Helper function to process markdown and get the resulting tree
+const processMarkdown = (markdown: string, tagName: string) => {
+  const processor = unified().use(remarkParse).use(createRemarkSelfClosingTagPlugin(tagName));
+
+  const tree = processor.parse(markdown);
+  return processor.runSync(tree);
+};
+
+describe('createRemarkSelfClosingTagPlugin', () => {
+  const tagName = 'localFile';
+
+  it('should replace a single self-closing tag (parsed as HTML) with a custom node', () => {
+    const markdown = `<${tagName} name="test.txt" path="/path/to/test.txt" />`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    const node = tree.children[0];
+    expect(node.type).toBe(tagName);
+    expect(node.data?.hProperties).toEqual({
+      name: 'test.txt',
+      path: '/path/to/test.txt',
+    });
+    expect(node.data?.hName).toBe(tagName);
+  });
+
+  it('should handle boolean attributes in a standalone tag', () => {
+    const markdown = `<${tagName} name="docs" path="/path/to/docs" isDirectory />`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    const node = tree.children[0];
+    expect(node.type).toBe(tagName);
+    expect(node.data?.hProperties).toEqual({
+      name: 'docs',
+      path: '/path/to/docs',
+      isDirectory: true,
+    });
+    expect(node.data?.hName).toBe(tagName);
+  });
+
+  it('should handle tags surrounded by text (parsed within paragraph)', () => {
+    const markdown = `Here is a file: <${tagName} name="report.pdf" path="report.pdf" /> Please review.`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].type).toBe('paragraph');
+
+    const paragraphChildren = tree.children[0].children;
+    expect(paragraphChildren).toHaveLength(3);
+
+    expect(paragraphChildren[0].type).toBe('text');
+    expect(paragraphChildren[0].value).toBe('Here is a file: ');
+
+    const tagNode = paragraphChildren[1];
+    expect(tagNode.type).toBe(tagName);
+    expect(tagNode.data?.hProperties).toEqual({
+      name: 'report.pdf',
+      path: 'report.pdf',
+    });
+    expect(tagNode.data?.hName).toBe(tagName);
+
+    expect(paragraphChildren[2].type).toBe('text');
+    expect(paragraphChildren[2].value).toBe(' Please review.');
+  });
+
+  it('should handle multiple tags within the same text block', () => {
+    const markdown = `File 1: <${tagName} name="a.txt" path="a" /> and File 2: <${tagName} name="b.txt" path="b" isDirectory />`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].type).toBe('paragraph');
+
+    const paragraphChildren = tree.children[0].children;
+    expect(paragraphChildren).toHaveLength(4);
+
+    expect(paragraphChildren[0].value).toBe('File 1: ');
+
+    const tagNode1 = paragraphChildren[1];
+    expect(tagNode1.type).toBe(tagName);
+    expect(tagNode1.data?.hProperties).toEqual({ name: 'a.txt', path: 'a' });
+    expect(tagNode1.data?.hName).toBe(tagName);
+
+    expect(paragraphChildren[2].value).toBe(' and File 2: ');
+
+    const tagNode2 = paragraphChildren[3];
+    expect(tagNode2.type).toBe(tagName);
+    expect(tagNode2.data?.hProperties).toEqual({
+      name: 'b.txt',
+      path: 'b',
+      isDirectory: true,
+    });
+    expect(tagNode2.data?.hName).toBe(tagName);
+  });
+
+  it('should handle standalone tags with no attributes', () => {
+    const markdown = `<${tagName} />`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    const node = tree.children[0];
+    expect(node.type).toBe(tagName);
+    expect(node.data?.hProperties).toEqual({});
+    expect(node.data?.hName).toBe(tagName);
+  });
+
+  it('should ignore tags with different names (parsed within a paragraph)', () => {
+    const markdown = `<other_tag name="ignore_me" /> <${tagName} name="process_me" path="/p" />`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].type).toBe('paragraph');
+
+    const paragraphChildren = tree.children[0].children;
+    expect(paragraphChildren).toHaveLength(2);
+
+    expect(paragraphChildren[0].type).toBe('text');
+    expect(paragraphChildren[0].value).toBe('<other_tag name="ignore_me" /> ');
+
+    const tagNode = paragraphChildren[1];
+    expect(tagNode.type).toBe(tagName);
+    expect(tagNode.data?.hProperties).toEqual({ name: 'process_me', path: '/p' });
+    expect(tagNode.data?.hName).toBe(tagName);
+  });
+
+  it('should not modify markdown without the target tag', () => {
+    const markdown = 'This is just regular text.';
+    const tree = processMarkdown(markdown, tagName);
+    const originalTree = unified().use(remarkParse).parse(markdown);
+
+    expect(tree).toEqual(originalTree);
+  });
+
+  it('should work with a different tag name provided to the creator', () => {
+    const otherTagName = 'customData';
+    const markdown = `Data: <${otherTagName} id="123" value="abc" active />`;
+    const tree = processMarkdown(markdown, otherTagName);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].type).toBe('paragraph');
+    const paragraphChildren = tree.children[0].children;
+    expect(paragraphChildren).toHaveLength(2);
+
+    expect(paragraphChildren[0].value).toBe('Data: ');
+
+    const tagNode = paragraphChildren[1];
+    expect(tagNode.type).toBe(otherTagName);
+    expect(tagNode.data?.hProperties).toEqual({ id: '123', value: 'abc', active: true });
+    expect(tagNode.data?.hName).toBe(otherTagName);
+  });
+
+  it('should handle tag at the beginning of the text', () => {
+    const markdown = `<${tagName} name="start.log" path="/logs/start.log" /> Log started.`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].type).toBe('paragraph');
+    const paragraphChildren = tree.children[0].children;
+    expect(paragraphChildren).toHaveLength(2);
+
+    const tagNode = paragraphChildren[0];
+    expect(tagNode.type).toBe(tagName);
+    expect(tagNode.data?.hProperties).toEqual({ name: 'start.log', path: '/logs/start.log' });
+    expect(tagNode.data?.hName).toBe(tagName);
+
+    expect(paragraphChildren[1].type).toBe('text');
+    expect(paragraphChildren[1].value).toBe(' Log started.');
+  });
+
+  it('should handle tag at the end of the text', () => {
+    const markdown = `Log ended: <${tagName} name="end.log" path="/logs/end.log" />`;
+    const tree = processMarkdown(markdown, tagName);
+
+    expect(tree.children).toHaveLength(1);
+    expect(tree.children[0].type).toBe('paragraph');
+    const paragraphChildren = tree.children[0].children;
+    expect(paragraphChildren).toHaveLength(2);
+
+    expect(paragraphChildren[0].type).toBe('text');
+    expect(paragraphChildren[0].value).toBe('Log ended: ');
+
+    const tagNode = paragraphChildren[1];
+    expect(tagNode.type).toBe(tagName);
+    expect(tagNode.data?.hProperties).toEqual({ name: 'end.log', path: '/logs/end.log' });
+    expect(tagNode.data?.hName).toBe(tagName);
+  });
+
+  it('should handle tag within a list item and generate snapshot', () => {
+    const markdown = `
+1. 文件名：飞机全书 一部明晰可见的历史.pdf
+   - 路径1：<${tagName} name="飞机全书 一部明晰可见的历史.pdf" path="/Users/abc/Zotero/storage/ASBMAURK/飞机全书 一部明晰可见的历史.pdf" />
+   - 路径2：/Users/abc/Downloads/测试 PDF/飞机全书 一部明晰可见的历史.pdf
+
+这是一本 PDF 格式的书，并且在你的 Zotero 和 Downloads 文件夹里都能找到。如果需要进一步操作，比如阅读或者提取内容，可以告诉我
+`;
+    const tree = processMarkdown(markdown, tagName);
+    expect(tree).toMatchSnapshot();
+  });
+});

package/src/features/Conversation/components/MarkdownElements/remarkPlugins/createRemarkSelfClosingTagPlugin.ts

@@ -0,0 +1,133 @@
+import debug from 'debug';
+import type { Plugin } from 'unified';
+import { SKIP, visit } from 'unist-util-visit';
+
+// 创建 debugger 实例
+const log = debug('lobe-markdown:remark-plugin:self-closing');
+
+// Regex to parse attributes from a string
+// Handles keys, keys with quoted values (double or single), and boolean keys
+const attributeRegex = /([\w-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+
+// Helper function to parse the attribute string into an object
+const parseAttributes = (attributeString: string): Record<string, string | boolean> => {
+  const attributes: Record<string, string | boolean> = {};
+  let match;
+  while ((match = attributeRegex.exec(attributeString)) !== null) {
+    const [, key, valueDouble, valueSingle, valueUnquoted] = match;
+    // If any value group is captured, use it, otherwise treat as boolean true
+    attributes[key] = valueDouble ?? valueSingle ?? valueUnquoted ?? true;
+  }
+  return attributes;
+};
+
+export const createRemarkSelfClosingTagPlugin =
+  (tagName: string): Plugin<[], any> =>
+  () => {
+    // Regex for the specific tag, ensure it matches the entire string for HTML check
+    const exactTagRegex = new RegExp(`^<${tagName}(\\s+[^>]*?)?\\s*\\/>$`);
+    // Regex for finding tags within text
+    const textTagRegex = new RegExp(`<${tagName}(\\s+[^>]*?)?\\s*\\/>`, 'g');
+
+    return (tree) => {
+      // --- DEBUG LOG START (Before Visit) ---
+      log('Plugin execution start for tag: %s', tagName);
+      log('Tree: %o', tree);
+      log('Tree type: %s', tree?.type);
+      log('Tree children count: %d', tree?.children?.length);
+      if (!tree || !Array.isArray(tree.children)) {
+        log('ERROR: Invalid Tree Structure Detected Before Visit! %o', tree);
+      } else {
+        const hasUndefinedChild = tree.children.includes(undefined);
+        if (hasUndefinedChild) {
+          log('ERROR: Tree contains undefined children Before Visit!');
+          log(
+            'Children types: %o',
+            tree.children.map((c: any) => c?.type),
+          );
+        }
+      }
+      log('---------------------------------------------------');
+      // --- DEBUG LOG END (Before Visit) ---
+
+      // 1. Visit HTML nodes first for exact matches
+      // @ts-ignore
+      visit(tree, 'html', (node, index: number, parent) => {
+        log('>>> Visiting HTML node: %s', node.value);
+        const match = node.value.match(exactTagRegex);
+
+        if (match && parent && typeof index === 'number') {
+          const [, attributesString] = match;
+          const properties = attributesString ? parseAttributes(attributesString.trim()) : {};
+
+          const newNode = {
+            data: {
+              hName: tagName,
+              hProperties: properties,
+            },
+            type: tagName,
+          };
+
+          log('Replacing HTML node at index %d with %s node: %o', index, tagName, newNode);
+          parent.children.splice(index, 1, newNode);
+          return [SKIP, index + 1]; // Skip the node we just inserted
+        }
+      });
+
+      // 2. Visit Text nodes for inline matches
+      // @ts-ignore
+      visit(tree, 'text', (node: any, index: number, parent) => {
+        log('>>> Visiting Text node: "%s"', node.value);
+
+        if (!parent || typeof index !== 'number' || !node.value?.includes(`<${tagName}`)) {
+          return; // Quick exit if tag isn't possibly present
+        }
+
+        const text = node.value;
+        let lastIndex = 0;
+        const newChildren = [];
+        let match;
+
+        textTagRegex.lastIndex = 0; // Reset regex state
+
+        while ((match = textTagRegex.exec(text)) !== null) {
+          const [fullMatch, attributesString] = match;
+          const matchIndex = match.index;
+
+          // Add text before the match
+          if (matchIndex > lastIndex) {
+            newChildren.push({ type: 'text', value: text.slice(lastIndex, matchIndex) });
+          }
+
+          // Parse attributes and create the new node
+          const properties = attributesString ? parseAttributes(attributesString.trim()) : {};
+          newChildren.push({
+            data: {
+              hName: tagName,
+              hProperties: properties,
+            },
+            type: tagName,
+          });
+
+          lastIndex = matchIndex + fullMatch.length;
+        }
+
+        // If matches were found, replace the original text node
+        if (newChildren.length > 0) {
+          // Add any remaining text after the last match
+          if (lastIndex < text.length) {
+            newChildren.push({ type: 'text', value: text.slice(lastIndex) });
+          }
+
+          // --- DEBUG LOG START (Before Splice - Text Node) ---
+          log('--- Replacing Text Node Content ---');
+          log('Original text node index: %d', index);
+          log('-----------------------------------');
+          // --- DEBUG LOG END (Before Splice - Text Node) ---
+
+          parent.children.splice(index, 1, ...newChildren);
+          return [SKIP, index + newChildren.length]; // Skip new nodes
+        }
+      });
+    };
+  };

package/src/features/Conversation/components/MarkdownElements/type.ts

@@ -1,8 +1,12 @@
 import { FC, ReactNode } from 'react';
 
-export interface MarkdownElementProps {
+export interface MarkdownElementProps<T = any> {
   children: ReactNode;
   id: string;
+  node: {
+    properties: T;
+  };
+  tagName: string;
   type: string;
 }
 

package/src/features/PluginDevModal/MCPManifestForm/ArgsInput.tsx

@@ -0,0 +1,20 @@
+import { Input, InputProps } from 'antd';
+import { memo } from 'react';
+
+interface ArgsInputProps extends Omit<InputProps, 'value' | 'onChange'> {
+  onChange?: (value: string[]) => void;
+  value?: string[];
+}
+
+const ArgsInput = memo<ArgsInputProps>(({ value, onChange, ...res }) => {
+  return (
+    <Input
+      onChange={(e) => {
+        onChange?.([e.target.value]);
+      }}
+      value={value?.[0]}
+      {...res}
+    />
+  );
+});
+export default ArgsInput;