nolo-cli 0.1.23 → 0.1.29

package/core/init.ts

@@ -0,0 +1,41 @@
+import { BUILTIN_NOLO_AGENT_KEY } from "./builtinAgents";
+
+export const nolotusId = "0e95801d90";
+export const copilotDemoId = "b2e06f801f";
+
+const ADMIN_IDS = new Set([nolotusId, copilotDemoId]);
+
+export const isSystemAdmin = (userId?: string | null) =>
+  userId != null && ADMIN_IDS.has(userId);
+
+export const AI_ADMIN_ROLE = "AI管理员";
+
+const envAiAdminIds = () =>
+  new Set(
+    (process.env.AI_ADMIN_USER_IDS ?? "")
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean)
+  );
+
+const recordHasAiAdminRole = (record: unknown): boolean => {
+  if (!record || typeof record !== "object") return false;
+  const value = record as Record<string, unknown>;
+  const scalarFields = [value.role, value.globalRole, value.systemRole];
+  if (scalarFields.some((item) => item === AI_ADMIN_ROLE)) return true;
+  const listFields = [value.roles, value.globalRoles, value.systemRoles, value.permissions];
+  return listFields.some(
+    (item) => Array.isArray(item) && item.includes(AI_ADMIN_ROLE)
+  );
+};
+
+export const isAIAdmin = (
+  userId?: string | null,
+  ...records: unknown[]
+) =>
+  isSystemAdmin(userId) ||
+  (userId != null && envAiAdminIds().has(userId)) ||
+  records.some(recordHasAiAdminRole);
+
+export const legacyNoloAgentId = "cybot-pub-01JYRSTM0MPPGQC9S25S3Y9J20";
+export const noloAgentId = BUILTIN_NOLO_AGENT_KEY;

package/core/localOrigins.ts

@@ -0,0 +1,8 @@
+export const DEFAULT_LOCAL_HOST = "127.0.0.1";
+export const DEFAULT_LOCAL_API_PORT = "38123";
+
+export const DEFAULT_LOCAL_API_ORIGIN = `http://${DEFAULT_LOCAL_HOST}:${DEFAULT_LOCAL_API_PORT}`;
+
+export function normalizeOrigin(value: string): string {
+  return value.trim().replace(/\/+$/, "");
+}

package/core/password.ts

@@ -0,0 +1,13 @@
+import CryptoJS from "crypto-js";
+import { SALT, AUTH_VERSION } from ".//config";
+
+export const hashPasswordV1 = async (password: string): Promise<string> => {
+  const hash = CryptoJS.PBKDF2(password, SALT, {
+    keySize: 256 / AUTH_VERSION[1].keylen,
+    iterations: AUTH_VERSION[1].iterations,
+    hasher: CryptoJS.algo.SHA512,
+  });
+
+  // 将 salt 和 hash 组合存储
+  return hash.toString(CryptoJS.enc.Base64);
+};

package/core/prefix.ts

@@ -0,0 +1,23 @@
+const extractKeyPart = (key: string, index: number): string => {
+  const parts = key.split("-");
+  if (index < 2) {
+    return parts[index];
+  }
+  return parts.slice(index).join("-");
+};
+
+export const extractUserId = (key: string): string => {
+  const parts = key.split("-");
+
+  if (parts.length === 2) {
+    return parts[0];
+  }
+
+  if (parts[0] === "user" && parts[1] === "pref" && parts.length >= 3) {
+    return parts[2];
+  }
+
+  return extractKeyPart(key, 1);
+};
+
+export const extractCustomId = (key: string): string => extractKeyPart(key, 2);

package/create/editor/blockCommands.ts

@@ -0,0 +1,118 @@
+import { Editor, Element as SlateElement, Node, Path, Transforms } from "slate";
+
+const LIST_TYPE = "list";
+
+export type ListVariant = "ordered" | "unordered" | "task" | null;
+
+const isListItem = (node: unknown): node is SlateElement =>
+  SlateElement.isElement(node) && node.type === "list-item";
+
+export const isBlockActive = (
+  editor: Editor,
+  format: string,
+  blockType: "type" | "align" = "type"
+) => {
+  const { selection } = editor;
+  if (!selection) return false;
+
+  const [match] = Array.from(
+    Editor.nodes(editor, {
+      at: Editor.unhangRange(editor, selection),
+      match: (n) =>
+        !Editor.isEditor(n) &&
+        SlateElement.isElement(n) &&
+        (n as any)[blockType] === format,
+    })
+  );
+
+  return !!match;
+};
+
+export const getActiveListVariant = (editor: Editor): ListVariant => {
+  const { selection } = editor;
+  if (!selection) return null;
+
+  const [listItemEntry] = Editor.nodes(editor, {
+    at: Editor.unhangRange(editor, selection),
+    match: (n) => !Editor.isEditor(n) && isListItem(n),
+  });
+
+  if (!listItemEntry) return null;
+
+  const [listItemNode, listItemPath] = listItemEntry;
+  if ((listItemNode as any).checked !== undefined) {
+    return "task";
+  }
+
+  const parentNode = Node.get(editor, Path.parent(listItemPath));
+  if (!SlateElement.isElement(parentNode) || parentNode.type !== LIST_TYPE) {
+    return null;
+  }
+
+  return parentNode.ordered ? "ordered" : "unordered";
+};
+
+const unwrapFromList = (editor: Editor) => {
+  Transforms.unwrapNodes(editor, {
+    match: (n) =>
+      !Editor.isEditor(n) &&
+      SlateElement.isElement(n) &&
+      n.type === LIST_TYPE,
+    split: true,
+  });
+};
+
+// Toolbar and markdown shortcuts share these commands so list switching stays consistent
+// regardless of whether the user clicks a button or types a shortcut.
+export const setBlockType = (editor: Editor, type: string) => {
+  unwrapFromList(editor);
+  Transforms.unsetNodes(editor, "checked", {
+    match: (n) => !Editor.isEditor(n) && isListItem(n),
+  });
+  Transforms.setNodes(editor, { type } as Partial<SlateElement>);
+};
+
+const applyListVariant = (
+  editor: Editor,
+  variant: Exclude<ListVariant, null>
+) => {
+  const currentVariant = getActiveListVariant(editor);
+  const isSameVariant = currentVariant === variant;
+
+  unwrapFromList(editor);
+
+  if (isSameVariant) {
+    Transforms.unsetNodes(editor, "checked", {
+      match: (n) => !Editor.isEditor(n) && isListItem(n),
+    });
+    Transforms.setNodes(editor, { type: "paragraph" } as Partial<SlateElement>);
+    return;
+  }
+
+  Transforms.setNodes(editor, { type: "list-item" } as Partial<SlateElement>);
+
+  if (variant === "task") {
+    Transforms.setNodes(editor, { checked: false } as Partial<SlateElement>, {
+      match: (n) => !Editor.isEditor(n) && isListItem(n),
+    });
+  } else {
+    Transforms.unsetNodes(editor, "checked", {
+      match: (n) => !Editor.isEditor(n) && isListItem(n),
+    });
+  }
+
+  Transforms.wrapNodes(editor, {
+    type: LIST_TYPE,
+    ordered: variant === "ordered",
+    children: [],
+  });
+};
+
+export const toggleOrderedList = (editor: Editor) =>
+  applyListVariant(editor, "ordered");
+
+export const toggleBulletedList = (editor: Editor) =>
+  applyListVariant(editor, "unordered");
+
+export const toggleTaskList = (editor: Editor) =>
+  applyListVariant(editor, "task");

package/create/editor/highlightExample.ts

@@ -0,0 +1,66 @@
+import { CodeBlockType, CodeLineType, ParagraphType } from "./types";
+
+const toChildren = (content) => [{ text: content }];
+
+const toCodeLines = (content) =>
+  content
+    .split("\n")
+    .map((line) => ({ type: CodeLineType, children: toChildren(line) }));
+
+export const initialValue = [
+  {
+    type: ParagraphType,
+    children: toChildren(
+      "Here's one containing a single paragraph block with some text in it:"
+    ),
+  },
+  {
+    type: CodeBlockType,
+    language: "jsx",
+    children: toCodeLines(`// Add the initial value.
+  const initialValue = [
+    {
+      type: 'paragraph',
+      children: [{ text: 'A line of text in a paragraph.' }]
+    }
+  ]
+  
+  const App = () => {
+    const [editor] = useState(() => withReact(createEditor()))
+  
+    return (
+      <Slate editor={editor} initialValue={initialValue}>
+        <Editable />
+      </Slate>
+    )
+  }`),
+  },
+  {
+    type: ParagraphType,
+    children: toChildren(
+      "If you are using TypeScript, you will also need to extend the Editor with ReactEditor and add annotations as per the documentation on TypeScript. The example below also includes the custom types required for the rest of this example."
+    ),
+  },
+  {
+    type: CodeBlockType,
+    language: "typescript",
+    children: toCodeLines(`// TypeScript users only add this code
+  import { BaseEditor, Descendant } from 'slate'
+  import { ReactEditor } from 'slate-react'
+  
+  type CustomElement = { type: 'paragraph'; children: CustomText[] }
+  type CustomText = { text: string }
+  
+  declare module 'slate' {
+    interface CustomTypes {
+      Editor: BaseEditor & ReactEditor
+      Element: CustomElement
+      Text: CustomText
+    }
+  }`),
+  },
+  {
+    type: ParagraphType,
+    children: toChildren("There you have it!"),
+  },
+];

package/create/editor/imageUpload.ts

@@ -0,0 +1,66 @@
+// 文件：create/editor/imageUpload.ts
+
+import { Editor, Transforms } from "slate";
+import type { AppDispatch } from "../../app/store";
+import { upload } from "../../database/dbSlice";
+import { uploadAndAddFileToSpace } from "../space/spaceSlice";
+import { toast } from "react-hot-toast";
+
+const createCustomKey = (file: File) =>
+    `slate-image-${file.lastModified}-${file.size}-${Math.random()
+        .toString(36)
+        .slice(2)}`;
+
+/**
+ * 从 File 上传并在当前 selection 处插入 image 节点。
+ * - 带「上传中」Loading toast；
+ * - 成功 / 失败 toast；
+ * - 返回 fileId（失败返回 null）。
+ */
+export const insertImageFromFile = async (
+    editor: Editor,
+    dispatch: AppDispatch | any,
+    file: File,
+    spaceId?: string
+): Promise<string | null> => {
+    const customKey = createCustomKey(file);
+    const toastId = toast.loading(`正在上传图片…`);
+
+    try {
+        let metadata: any;
+
+        if (spaceId) {
+            // 如果在空间内，关联到空间
+            metadata = await dispatch(
+                uploadAndAddFileToSpace({ spaceId, file })
+            ).unwrap();
+        } else {
+            // 否则仅上传（旧逻辑）
+            metadata = await dispatch(
+                upload({ file, customKey })
+            ).unwrap();
+        }
+
+        // extract the actual fileId (ULID) for content loading
+        const fileId = metadata?.fileId || metadata?.id || metadata?.dbKey;
+        if (!fileId) {
+            toast.error("上传失败：未返回文件 ID", { id: toastId });
+            return null;
+        }
+
+        const imageNode: any = {
+            type: "image",
+            fileId,
+            alt: file.name,
+            children: [{ text: "" }], // children = Caption
+        };
+
+        Transforms.insertNodes(editor, imageNode);
+        toast.success("图片上传成功", { id: toastId });
+
+        return fileId;
+    } catch {
+        toast.error("图片上传失败", { id: toastId });
+        return null;
+    }
+};

package/create/editor/mark.ts

@@ -0,0 +1,15 @@
+import { Editor } from "slate";
+
+export const toggleMark = (editor, format) => {
+  const isActive = isMarkActive(editor, format);
+  if (isActive) {
+    Editor.removeMark(editor, format);
+  } else {
+    Editor.addMark(editor, format, true);
+  }
+};
+
+export const isMarkActive = (editor, format) => {
+  const marks = Editor.marks(editor);
+  return marks ? marks[format] === true : false;
+};

package/create/editor/plugins/normalizeChineseTypography.ts

@@ -0,0 +1,85 @@
+// editor/plugins/normalizeChineseTypography.ts
+export const normalizeChineseTypography = (input: string): string => {
+  let text = input;
+
+  // ===== 0. 提前返回：空字符串／全空白没必要处理 =====
+  if (!text || !text.trim()) return text;
+
+  // ===== 1. 折叠重复标点：！！ → ！, ？？ → ？ 等 =====
+  text = text
+    // 折叠英文/中文叹号
+    .replace(/[!！]{2,}/g, "！")
+    // 折叠英文/中文问号
+    .replace(/[?？]{2,}/g, "？")
+    // 连续逗号
+    .replace(/[,，]{2,}/g, "，")
+    // 连续句号
+    .replace(/[.。]{2,}/g, "。");
+
+  // ===== 2. 半角标点在 CJK 附近时替换成全角 =====
+  // CJK 统一表意文字范围（含中日韓扩展示意，够用即可）
+  const CJK_RANGE = "\\u3400-\\u4DBF\\u4E00-\\u9FFF\\uF900-\\uFAFF";
+  const CJK = `[${CJK_RANGE}]`;
+
+  const fullWidthPunctMap: Record<string, string> = {
+    ",": "，",
+    ".": "。",
+    "!": "！",
+    "?": "？",
+    ":": "：",
+    ";": "；",
+  };
+
+  // CJK + 半角标点 → CJK + 全角标点
+  text = text.replace(
+    new RegExp(`(${CJK})([,.!?:;])`, "g"),
+    (_, cjk: string, p: string) => cjk + (fullWidthPunctMap[p] ?? p)
+  );
+
+  // 半角标点 + CJK → 全角标点 + CJK
+  text = text.replace(
+    new RegExp(`([,.!?:;])(${CJK})`, "g"),
+    (_, p: string, cjk: string) => (fullWidthPunctMap[p] ?? p) + cjk
+  );
+
+  // ===== 3. 全角标点两侧不留空格 =====
+  // 「iPhone ， 好開心！」→「iPhone，好開心！」
+  text = text.replace(/\s*([，。！？：；])\s*/g, "$1");
+
+  // ===== 4. 中英文之间、中文与数字之间自动加空格 =====
+  // 说明：
+  // - CJK 与 ASCII/数字之间：在边界插入一个空格
+  // - 数字与 CJK：同理
+  // - 数字与英文单位：10Gbps → 10 Gbps   （不动 15% / 90°）
+  const ALNUM = "[A-Za-z0-9]";
+
+  // CJK + 英文/数字
+  text = text.replace(
+    new RegExp(`(${CJK})(${ALNUM})`, "g"),
+    "$1 $2"
+  );
+  // 英文/数字 + CJK
+  text = text.replace(
+    new RegExp(`(${ALNUM})(${CJK})`, "g"),
+    "$1 $2"
+  );
+
+  // 数字 + CJK（5000元 → 5000 元），这里冗余一层保证覆盖
+  text = text.replace(
+    new RegExp(`(${CJK})([0-9])`, "g"),
+    "$1 $2"
+  );
+  text = text.replace(
+    new RegExp(`([0-9])(${CJK})`, "g"),
+    "$1 $2"
+  );
+
+  // 数字 + 英文字母：10Gbps → 10 Gbps
+  // 注意：不会影响 15% / 90°，因为 % 和 ° 不在 [A-Za-z] 范围内
+  text = text.replace(/(\d)([A-Za-z])/, "$1 $2");
+
+  // ===== 5. 收尾：多空格压成单个空格（不动换行）=====
+  text = text.replace(/ {2,}/g, " ");
+
+  return text;
+};

package/create/editor/plugins/withBlockStructure.ts

@@ -0,0 +1,53 @@
+import { Editor, Element as SlateElement, Node, Transforms } from "slate";
+
+const HEADING_TYPES = new Set([
+  "heading-one",
+  "heading-two",
+  "heading-three",
+  "heading-four",
+  "heading-five",
+  "heading-six",
+  "quote",
+  "thematic-break",
+]);
+
+const isList = (node: unknown): node is SlateElement =>
+  SlateElement.isElement(node) && node.type === "list";
+
+const isListItem = (node: unknown): node is SlateElement =>
+  SlateElement.isElement(node) && node.type === "list-item";
+
+export const withBlockStructure = (editor: Editor) => {
+  const { normalizeNode } = editor;
+
+  editor.normalizeNode = ([node, path]) => {
+    if (isList(node)) {
+      // Keep list children structurally predictable even when pasted/AI-generated content is messy.
+      for (const [child, childPath] of Node.children(editor, path)) {
+        if (!isListItem(child)) {
+          Transforms.wrapNodes(
+            editor,
+            { type: "list-item", children: [] },
+            { at: childPath }
+          );
+          return;
+        }
+      }
+    }
+
+    if (isListItem(node)) {
+      // We deliberately keep list storage flat, but the editable content of each item
+      // should still behave like body text instead of headings/dividers.
+      for (const [child, childPath] of Node.children(editor, path)) {
+        if (SlateElement.isElement(child) && HEADING_TYPES.has(child.type)) {
+          Transforms.setNodes(editor, { type: "paragraph" }, { at: childPath });
+          return;
+        }
+      }
+    }
+
+    normalizeNode([node, path]);
+  };
+
+  return editor;
+};

package/create/editor/plugins/withChineseTypography.ts

@@ -0,0 +1,61 @@
+// editor/plugins/withChineseTypography.ts
+import { Editor, Element as SlateElement, NodeEntry, Text, Transforms } from "slate";
+import { normalizeChineseTypography } from "./normalizeChineseTypography";
+
+type AnyEditor = Editor & {
+  // 如果你有自定义的 editor 类型，可以在这扩展
+};
+
+
+const isTypographyDisabled = (editor: Editor, entry: NodeEntry): boolean => {
+  const [, path] = entry;
+
+  // 避免在 code block / inline code / 链接等节点里改文本
+  const block = Editor.above(editor, {
+    at: path,
+    match: (n) =>
+      SlateElement.isElement(n) &&
+      [
+        "code-block",
+        "code-line",
+        "code-inline", // 这里原来是 "inline-code"，建议改成和实际类型一致
+        "link",
+      ].includes((n as any).type),
+  });
+
+  return Boolean(block);
+};
+
+export const withChineseTypography = <T extends AnyEditor>(editor: T): T => {
+  const { normalizeNode } = editor;
+
+  editor.normalizeNode = (entry: NodeEntry) => {
+    const [node, path] = entry;
+
+    // 只处理纯文本节点
+    if (Text.isText(node)) {
+      if (isTypographyDisabled(editor, entry)) {
+        return normalizeNode(entry);
+      }
+
+      const original = node.text;
+      const normalized = normalizeChineseTypography(original);
+
+      if (normalized !== original) {
+        // 替换当前 text 节点的内容
+        Transforms.setNodes(
+          editor,
+          { text: normalized },
+          { at: path }
+        );
+        // 重要：修改之后提前返回，避免无限 normalize 循环
+        return;
+      }
+    }
+
+    // 默认行为
+    normalizeNode(entry);
+  };
+
+  return editor;
+};

package/create/editor/plugins/withLayout.ts

@@ -0,0 +1,30 @@
+// 文件路径: create/editor/plugins/withLayout.ts
+
+import { Transforms, Element as SlateElement, Editor } from "slate";
+
+export const withLayout = (editor: Editor) => {
+  const { normalizeNode } = editor;
+
+  editor.normalizeNode = (entry) => {
+    const [node, path] = entry;
+
+    // 只在根节点应用布局规则
+    if (Editor.isEditor(node) && path.length === 0) {
+      const children = node.children;
+
+      // body-only 编辑器至少保留一个段落，标题已移到外层输入框
+      if (children.length === 0) {
+        const paragraph: SlateElement = {
+          type: "paragraph",
+          children: [{ text: "" }],
+        };
+        Transforms.insertNodes(editor, paragraph, { at: [0] });
+        return;
+      }
+    }
+
+    return normalizeNode(entry);
+  };
+
+  return editor;
+};

package/create/editor/plugins/withLinks.ts

@@ -0,0 +1,13 @@
+// create/editor/withLinks.ts
+import { Editor, Element, Range, Transforms } from "slate";
+
+export const withLinks = (editor: Editor) => {
+  const { isInline } = editor;
+
+  // 扩展现有的 isInline 方法，而不是覆盖它
+  editor.isInline = (element) => {
+    return element.type === "link" ? true : isInline(element);
+  };
+
+  return editor;
+};

package/create/editor/plugins/withMentions.ts

@@ -0,0 +1,15 @@
+import { Editor } from "slate";
+
+export const withMentions = (editor: Editor) => {
+    const { isInline, isVoid } = editor;
+
+    editor.isInline = (element: any) => {
+        return element.type === "mention" ? true : isInline(element);
+    };
+
+    editor.isVoid = (element: any) => {
+        return element.type === "mention" ? true : isVoid(element);
+    };
+
+    return editor;
+};

package/create/editor/plugins/withTables.ts

@@ -0,0 +1,52 @@
+import { Editor, Transforms, Element as SlateElement, Path } from "slate";
+
+export const withTables = (editor: Editor) => {
+  const { normalizeNode } = editor;
+
+  // 重写 normalizeNode 方法
+  editor.normalizeNode = ([node, path]) => {
+    // 检查节点是否为 table 类型
+    if (node.type === "table") {
+      const element = node as SlateElement;
+      let maxColumns = 0;
+      let columnMismatch = false;
+
+      // 1. 确保表格至少有一行一列
+      if (!element.children || element.children.length === 0) {
+        Transforms.removeNodes(editor, { at: path });
+        return;
+      }
+
+      // 2. 遍历所有行，计算最大列数
+      for (const child of element.children) {
+        if (SlateElement.isElement(child) && child.type === "table-row") {
+          const row = child as SlateElement;
+          maxColumns = Math.max(maxColumns, row.children?.length || 0);
+        }
+      }
+
+      // 3. 检查 'columns' 属性是否存在且长度是否正确
+      const columns = element.columns as any[];
+      if (!columns || columns.length !== maxColumns) {
+        columnMismatch = true;
+      }
+
+      if (columnMismatch && maxColumns > 0) {
+        // 如果 columns 属性不正确，则创建或重置它
+        const newColumns = Array.from({ length: maxColumns }, () => ({
+          width: null, // 默认宽度
+          align: "left",
+        }));
+
+        Transforms.setNodes(editor, { columns: newColumns }, { at: path });
+        // console.log(`[withTables] Normalized table at path [${path}]: set columns to`, newColumns);
+        return; // 返回以允许 Slate 重新运行规范化
+      }
+    }
+
+    // 对于其他所有节点，调用原始的 normalizeNode
+    return normalizeNode([node, path]);
+  };
+
+  return editor;
+};