nolo-cli 0.1.40 → 0.1.42

package/ai/tools/deleteSpacesTool.ts

@@ -0,0 +1,325 @@
+import { selectUserId } from "../../auth/authSlice";
+import { createSpaceKey } from "../../create/space/spaceKeys";
+import { deleteSpace, selectAllMemberSpaces } from "../../create/space/spaceSlice";
+import { read } from "../../database/dbSlice";
+import { getRuntimeServerContext } from "../../database/runtimeServerContext";
+
+import {
+  buildDeleteSpacesPreview,
+  filterSpaceDeletionCandidates,
+  resolveConfirmedSpaceDeletionTargets,
+  type DeleteSpacesMatchMode,
+  type SpaceDeletionPreview,
+  type SpaceMembershipLike,
+  type SpaceRecordLike,
+} from "./deleteSpacesToolModel";
+
+export interface DeleteSpacesToolArgs {
+  query: string;
+  matchMode?: DeleteSpacesMatchMode;
+  confirmedSpaceIds?: string[];
+}
+
+interface DeleteSpacesToolDeps {
+  selectCurrentUserId: (state: any) => string | undefined;
+  selectMemberSpaces: (state: any) => SpaceMembershipLike[];
+  readSpaceRecord: (thunkApi: any, spaceId: string) => Promise<SpaceRecordLike | null>;
+  selectDeleteServers: (state: any) => string[];
+  deleteServerKey: (
+    thunkApi: any,
+    server: string,
+    dbKey: string
+  ) => Promise<{ ok: boolean; status: number; detail: string }>;
+  deleteOwnedSpace: (
+    thunkApi: any,
+    input: { spaceId: string; strategy: "delete-space-only" }
+  ) => Promise<void>;
+}
+
+export const deleteSpacesFunctionSchema = {
+  name: "deleteSpaces",
+  description: [
+    "按名称或 ID 查找并删除当前用户拥有的 Space。",
+    "这是危险操作：第一次调用会返回待删除列表并等待用户确认；确认后才执行删除。",
+    "默认只删除 Space 壳和成员关系，不删除其中挂载的 doc/dialog/file 内容。",
+    "非 owner 的 Space 会被跳过，不会删除。",
+  ].join("\n"),
+  parameters: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description:
+          "要删除的 Space 筛选词，例如 rn_owner_verify_0504，或配合 matchMode=spaceId 传入 space id。",
+      },
+      matchMode: {
+        type: "string",
+        enum: ["prefix", "exact", "contains", "spaceId"],
+        description:
+          "匹配方式。prefix=名称前缀，exact=名称完全匹配，contains=名称包含，spaceId=按 Space ID 匹配。默认 prefix。",
+        default: "prefix",
+      },
+      confirmedSpaceIds: {
+        type: "array",
+        items: { type: "string" },
+        description:
+          "可选：确认阶段要删除的 Space ID 列表。不传时，用户点击确认会删除预览列表中的全部可删除项。",
+      },
+    },
+    required: ["query"],
+  },
+};
+
+const defaultDeps: DeleteSpacesToolDeps = {
+  selectCurrentUserId: selectUserId,
+  selectMemberSpaces: (state) => selectAllMemberSpaces(state) as SpaceMembershipLike[],
+  readSpaceRecord: async (thunkApi, spaceId) => {
+    try {
+      const record = await thunkApi.dispatch(
+        read({ dbKey: createSpaceKey.space(spaceId), waitRemote: true } as any)
+      ).unwrap();
+      return record ?? null;
+    } catch {
+      return null;
+    }
+  },
+  selectDeleteServers: (state) => {
+    const { currentServer, remoteServers } = getRuntimeServerContext(state);
+    return remoteServers.length > 0
+      ? remoteServers
+      : currentServer
+        ? [currentServer]
+        : [];
+  },
+  deleteServerKey: async (thunkApi, server, dbKey) => {
+    const state = thunkApi.getState();
+    const token = state?.auth?.currentToken;
+    if (!server) {
+      return { ok: false, status: 0, detail: "missing server" };
+    }
+    if (!token) {
+      return { ok: false, status: 401, detail: "missing auth token" };
+    }
+
+    const res = await fetch(
+      `${server.replace(/\/+$/, "")}/api/v1/db/delete/${encodeURIComponent(dbKey)}`,
+      {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${token}` },
+      }
+    );
+    return {
+      ok: res.ok,
+      status: res.status,
+      detail: await res.text().catch(() => ""),
+    };
+  },
+  deleteOwnedSpace: async (thunkApi, input) => {
+    await thunkApi.dispatch(deleteSpace(input as any)).unwrap();
+  },
+};
+
+const readSpaceRecordsById = async (
+  thunkApi: any,
+  memberships: SpaceMembershipLike[],
+  deps: DeleteSpacesToolDeps
+) => {
+  const recordsById: Record<string, SpaceRecordLike | null> = {};
+
+  for (const membership of memberships) {
+    const spaceId = String(membership.spaceId ?? "").replace(/^space-/, "");
+    if (!spaceId) continue;
+    recordsById[spaceId] = await deps.readSpaceRecord(thunkApi, spaceId);
+  }
+
+  return recordsById;
+};
+
+const loadDeletionContext = async (
+  args: DeleteSpacesToolArgs,
+  thunkApi: any,
+  deps: DeleteSpacesToolDeps
+): Promise<{
+  currentUserId: string;
+  preview: SpaceDeletionPreview;
+  spaceRecordsById: Record<string, SpaceRecordLike | null>;
+  deleteServers: string[];
+}> => {
+  const state = thunkApi.getState();
+  const currentUserId = deps.selectCurrentUserId(state);
+  if (!currentUserId) {
+    throw new Error("deleteSpaces 需要当前登录用户。");
+  }
+
+  const memberships = deps.selectMemberSpaces(state);
+  const deleteServers = deps.selectDeleteServers(state);
+  const candidates = filterSpaceDeletionCandidates(memberships, {
+    query: args.query,
+    matchMode: args.matchMode,
+  });
+  const spaceRecordsById = await readSpaceRecordsById(thunkApi, candidates, deps);
+
+  const preview = buildDeleteSpacesPreview({
+    currentUserId,
+    candidates,
+    spaceRecordsById,
+  });
+
+  return { currentUserId, preview, spaceRecordsById, deleteServers };
+};
+
+const loadPreview = async (
+  args: DeleteSpacesToolArgs,
+  thunkApi: any,
+  deps: DeleteSpacesToolDeps
+): Promise<SpaceDeletionPreview> => {
+  const { preview } = await loadDeletionContext(args, thunkApi, deps);
+  return preview;
+};
+
+const spaceMemberKeysForDelete = (
+  currentUserId: string,
+  spaceId: string,
+  record: SpaceRecordLike
+) => {
+  const memberIds = new Set<string>([currentUserId]);
+  if (Array.isArray(record.members)) {
+    for (const memberId of record.members) {
+      if (typeof memberId === "string" && memberId.trim()) {
+        memberIds.add(memberId.trim());
+      }
+    }
+  } else if (record.members && typeof record.members === "object") {
+    for (const memberId of Object.keys(record.members)) {
+      if (memberId.trim()) memberIds.add(memberId.trim());
+    }
+  }
+  return Array.from(memberIds).map((memberId) =>
+    createSpaceKey.member(memberId, spaceId)
+  );
+};
+
+const formatPreview = (preview: SpaceDeletionPreview) => {
+  if (preview.deletable.length === 0 && preview.skipped.length === 0) {
+    return "没有找到匹配的 Space。";
+  }
+
+  const lines = [
+    `找到 ${preview.deletable.length} 个可删除 Space，${preview.skipped.length} 个跳过。`,
+    "",
+  ];
+
+  if (preview.deletable.length > 0) {
+    lines.push("将删除这些 Space 壳和成员关系，不删除其中 doc/dialog/file：");
+    for (const item of preview.deletable) {
+      lines.push(
+        `- ${item.name} (${item.spaceId})，成员 ${item.memberCount}，内容 ${item.contentCount}`
+      );
+    }
+    lines.push("");
+    lines.push("需要确认后才会删除。");
+  }
+
+  if (preview.skipped.length > 0) {
+    lines.push("跳过：");
+    for (const item of preview.skipped) {
+      const owner = item.ownerId ? `，owner=${item.ownerId}` : "";
+      lines.push(`- ${item.name || item.spaceId} (${item.spaceId})：${item.reason}${owner}`);
+    }
+  }
+
+  return lines.join("\n");
+};
+
+export function createDeleteSpacesToolHandlers(deps: DeleteSpacesToolDeps) {
+  return {
+    preview: async (args: DeleteSpacesToolArgs, thunkApi: any) => {
+      const preview = await loadPreview(args, thunkApi, deps);
+      return {
+        rawData: preview,
+        displayData: formatPreview(preview),
+      };
+    },
+    execute: async (args: DeleteSpacesToolArgs, thunkApi: any) => {
+      const { currentUserId, preview, spaceRecordsById, deleteServers } =
+        await loadDeletionContext(args, thunkApi, deps);
+      const confirmedIds =
+        Array.isArray(args.confirmedSpaceIds) && args.confirmedSpaceIds.length > 0
+          ? args.confirmedSpaceIds
+          : preview.deletable.map((item) => item.spaceId);
+      const { targets, missingConfirmedSpaceIds } =
+        resolveConfirmedSpaceDeletionTargets(preview, confirmedIds);
+
+      const deletedSpaceIds: string[] = [];
+      const deletedKeys: string[] = [];
+      const deletedRecords: Array<{ server: string; dbKey: string }> = [];
+      const failures: Array<{ server?: string; dbKey: string; status: number; detail: string }> = [];
+      for (const target of targets) {
+        const record = spaceRecordsById[target.spaceId];
+        if (!record) {
+          failures.push({
+            dbKey: createSpaceKey.space(target.spaceId),
+            status: 404,
+            detail: "space record disappeared before deletion",
+          });
+          continue;
+        }
+        if (deleteServers.length === 0) {
+          failures.push({
+            dbKey: createSpaceKey.space(target.spaceId),
+            status: 0,
+            detail: "no delete server configured",
+          });
+          continue;
+        }
+        const keys = [
+          ...spaceMemberKeysForDelete(currentUserId, target.spaceId, record),
+          createSpaceKey.space(target.spaceId),
+        ];
+        let targetFailed = false;
+        for (const server of deleteServers) {
+          for (const dbKey of keys) {
+            const result = await deps.deleteServerKey(thunkApi, server, dbKey);
+            if (!result.ok) {
+              targetFailed = true;
+              failures.push({ server, dbKey, status: result.status, detail: result.detail });
+            } else {
+              deletedKeys.push(dbKey);
+              deletedRecords.push({ server, dbKey });
+            }
+          }
+        }
+        if (targetFailed) continue;
+
+        await deps.deleteOwnedSpace(thunkApi, {
+          spaceId: target.spaceId,
+          strategy: "delete-space-only",
+        });
+        deletedSpaceIds.push(target.spaceId);
+      }
+
+      const displayData =
+        deletedSpaceIds.length > 0
+          ? `已删除 ${deletedSpaceIds.length} 个 Space：${deletedSpaceIds.join(", ")}。内容记录未被删除。`
+          : "没有删除任何 Space。";
+
+      return {
+        rawData: {
+          deletedSpaceIds,
+          deletedKeys,
+          deletedRecords,
+          deleteServers,
+          missingConfirmedSpaceIds,
+          skipped: preview.skipped,
+          failures,
+        },
+        displayData,
+      };
+    },
+  };
+}
+
+const defaultHandlers = createDeleteSpacesToolHandlers(defaultDeps);
+
+export const deleteSpacesPreviewFunc = defaultHandlers.preview;
+export const deleteSpacesFunc = defaultHandlers.execute;

package/ai/tools/deleteSpacesToolModel.ts

@@ -0,0 +1,159 @@
+import { normalizeSpaceId } from "../../create/space/spaceKeys";
+
+export type DeleteSpacesMatchMode = "prefix" | "exact" | "contains" | "spaceId";
+
+export interface DeleteSpacesQuery {
+  query: string;
+  matchMode?: DeleteSpacesMatchMode;
+}
+
+export interface SpaceMembershipLike {
+  spaceId?: string;
+  spaceName?: string;
+  name?: string;
+  title?: string;
+  role?: string;
+  ownerId?: string;
+}
+
+export interface SpaceRecordLike {
+  id?: string;
+  name?: string;
+  title?: string;
+  ownerId?: string;
+  members?: string[] | Record<string, unknown>;
+  contents?: Record<string, unknown>;
+}
+
+export interface SpaceDeletionPreviewItem {
+  spaceId: string;
+  name: string;
+  ownerId: string | null;
+  memberCount: number;
+  contentCount: number;
+}
+
+export interface SkippedSpaceDeletionItem {
+  spaceId: string;
+  name: string;
+  reason: "missing_space_id" | "missing_space_record" | "not_owner";
+  ownerId?: string | null;
+}
+
+export interface SpaceDeletionPreview {
+  deletable: SpaceDeletionPreviewItem[];
+  skipped: SkippedSpaceDeletionItem[];
+}
+
+const getSpaceName = (membership: SpaceMembershipLike, record?: SpaceRecordLike) =>
+  String(
+    membership.spaceName ??
+      membership.name ??
+      membership.title ??
+      record?.name ??
+      record?.title ??
+      membership.spaceId ??
+      ""
+  ).trim();
+
+const countMembers = (members: SpaceRecordLike["members"]) => {
+  if (Array.isArray(members)) return members.length;
+  if (members && typeof members === "object") return Object.keys(members).length;
+  return 0;
+};
+
+export function filterSpaceDeletionCandidates(
+  memberships: SpaceMembershipLike[],
+  query: DeleteSpacesQuery
+) {
+  const rawQuery = String(query.query ?? "").trim();
+  if (!rawQuery) return [];
+  const matchMode = query.matchMode ?? "prefix";
+  const normalizedQuery = normalizeSpaceId(rawQuery).toLowerCase();
+  const textQuery = rawQuery.toLowerCase();
+
+  return memberships.filter((membership) => {
+    const spaceId = normalizeSpaceId(String(membership.spaceId ?? "")).toLowerCase();
+    const name = getSpaceName(membership).toLowerCase();
+
+    if (matchMode === "spaceId") return spaceId === normalizedQuery;
+    if (matchMode === "exact") return name === textQuery;
+    if (matchMode === "contains") return name.includes(textQuery);
+    return name.startsWith(textQuery);
+  });
+}
+
+export function buildDeleteSpacesPreview(args: {
+  currentUserId: string;
+  candidates: SpaceMembershipLike[];
+  spaceRecordsById: Record<string, SpaceRecordLike | null | undefined>;
+}): SpaceDeletionPreview {
+  const deletable: SpaceDeletionPreviewItem[] = [];
+  const skipped: SkippedSpaceDeletionItem[] = [];
+
+  for (const membership of args.candidates) {
+    const spaceId = normalizeSpaceId(String(membership.spaceId ?? ""));
+    const fallbackName = getSpaceName(membership);
+    if (!spaceId) {
+      skipped.push({
+        spaceId: "",
+        name: fallbackName,
+        reason: "missing_space_id",
+      });
+      continue;
+    }
+
+    const record = args.spaceRecordsById[spaceId];
+    const name = getSpaceName(membership, record ?? undefined) || spaceId;
+    if (!record) {
+      skipped.push({
+        spaceId,
+        name,
+        reason: "missing_space_record",
+      });
+      continue;
+    }
+
+    const ownerId = typeof record.ownerId === "string"
+      ? record.ownerId
+      : typeof membership.ownerId === "string"
+        ? membership.ownerId
+        : null;
+    if (ownerId && ownerId !== args.currentUserId) {
+      skipped.push({
+        spaceId,
+        name,
+        reason: "not_owner",
+        ownerId,
+      });
+      continue;
+    }
+
+    deletable.push({
+      spaceId,
+      name,
+      ownerId,
+      memberCount: countMembers(record.members),
+      contentCount:
+        record.contents && typeof record.contents === "object"
+          ? Object.keys(record.contents).length
+          : 0,
+    });
+  }
+
+  return { deletable, skipped };
+}
+
+export function resolveConfirmedSpaceDeletionTargets(
+  preview: SpaceDeletionPreview,
+  confirmedSpaceIds: string[]
+) {
+  const wanted = new Set(
+    confirmedSpaceIds.map((spaceId) => normalizeSpaceId(spaceId)).filter(Boolean)
+  );
+  const targets = preview.deletable.filter((item) => wanted.has(item.spaceId));
+  const found = new Set(targets.map((item) => item.spaceId));
+  const missingConfirmedSpaceIds = Array.from(wanted).filter((spaceId) => !found.has(spaceId));
+
+  return { targets, missingConfirmedSpaceIds };
+}

package/ai/tools/devReloadUtils.ts

@@ -0,0 +1,29 @@
+// 文件路径: packages/ai/tools/devReloadUtils.ts
+// Dev reload 抑制工具函数 - 用于自举编辑时延迟热更新
+
+/**
+ * 判断文件路径是否为项目源码（需要抑制 reload 的自举编辑）
+ * @param filePath 文件路径
+ * @returns 是否属于 packages/ 下的源码
+ */
+export function isSelfEditingPath(filePath: string): boolean {
+    if (!filePath) return false;
+    return filePath.replace(/\\/g, "/").startsWith("packages/");
+}
+
+/**
+ * 如果是自举编辑（改项目源码），增加 reload 抑制计数
+ * 这样 dev server 的热更新会被延迟到回答结束后再执行
+ * @param filePath 正在编辑的文件路径
+ */
+export function bumpDevReloadSuppressIfSelfEditing(filePath: string): void {
+    if (typeof window === "undefined") return;
+    if (!isSelfEditingPath(filePath)) return;
+
+    const w = window as any;
+    const cur = typeof w.__DEV_RELOAD_SUPPRESS_COUNT__ === "number" ? w.__DEV_RELOAD_SUPPRESS_COUNT__ : 0;
+    w.__DEV_RELOAD_SUPPRESS_COUNT__ = cur + 1;
+    w.__DEV_RELOAD_PENDING__ = false;
+
+    console.log("[devReloadSuppress] 自举编辑，增加 reload 抑制计数：", w.__DEV_RELOAD_SUPPRESS_COUNT__, "filePath:", filePath);
+}

package/ai/tools/dialogMessageSearch.ts

@@ -0,0 +1,137 @@
+export type DialogMessageSearchRecord = {
+  id?: string;
+  dbKey?: string;
+  role?: string;
+  content?: unknown;
+  toolName?: string;
+  createdAt?: string | number;
+};
+
+export type DialogMessageSearchResult = {
+  messageId: string | null;
+  dbKey: string | null;
+  role: string | null;
+  toolName: string | null;
+  createdAt: string | number | null;
+  content: string;
+  context: Array<{
+    messageId: string | null;
+    role: string | null;
+    toolName: string | null;
+    createdAt: string | number | null;
+    content: string;
+  }>;
+};
+
+export const normalizeDialogSearchText = (value: unknown): string =>
+  String(value ?? "").trim();
+
+export const clampDialogSearchNumber = (
+  value: unknown,
+  fallback: number,
+  min: number,
+  max: number,
+): number => {
+  const parsed = Number(value ?? fallback);
+  const safe = Number.isFinite(parsed) ? Math.floor(parsed) : fallback;
+  return Math.max(min, Math.min(max, safe));
+};
+
+export const buildDialogSearchMatcher = (query: string) => {
+  const normalizedQuery = query.toLowerCase();
+  const terms = normalizedQuery.split(/\s+/).filter(Boolean);
+  return (text: string) => {
+    const normalizedText = text.toLowerCase();
+    return normalizedText.includes(normalizedQuery) ||
+      (terms.length > 1 && terms.every((term) => normalizedText.includes(term)));
+  };
+};
+
+export const dialogMessageContentToText = (content: unknown): string => {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (part && typeof part === "object" && "text" in part) {
+        return String((part as { text?: unknown }).text ?? "");
+      }
+      return JSON.stringify(part);
+    }).join("\n");
+  }
+  if (content == null) return "";
+  return JSON.stringify(content);
+};
+
+export const clipDialogSearchText = (value: string, max: number): string => {
+  const trimmed = value.trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max)}\n...[truncated ${trimmed.length - max} chars]`;
+};
+
+export const buildDialogMessageSearchResults = (args: {
+  messages: DialogMessageSearchRecord[];
+  query: string;
+  limit: number;
+  contextMessages: number;
+  role?: string;
+  includeTools?: boolean;
+  contentClipChars: number;
+  contextClipChars: number;
+}): DialogMessageSearchResult[] => {
+  const matchesQuery = buildDialogSearchMatcher(args.query);
+  const includeTools = args.includeTools !== false;
+
+  return args.messages
+    .map((message, index) => ({
+      message,
+      index,
+      text: dialogMessageContentToText(message.content),
+    }))
+    .filter(({ message, text }) => {
+      if (!includeTools && message.role === "tool") return false;
+      if (args.role && message.role !== args.role) return false;
+      return matchesQuery(text);
+    })
+    .slice(0, args.limit)
+    .map(({ message, index, text }) => {
+      const start = Math.max(0, index - args.contextMessages);
+      const end = Math.min(args.messages.length, index + args.contextMessages + 1);
+      return {
+        messageId: message.id ?? null,
+        dbKey: message.dbKey ?? null,
+        role: message.role ?? null,
+        toolName: message.toolName ?? null,
+        createdAt: message.createdAt ?? null,
+        content: clipDialogSearchText(text, args.contentClipChars),
+        context: args.messages.slice(start, end).map((item) => ({
+          messageId: item.id ?? null,
+          role: item.role ?? null,
+          toolName: item.toolName ?? null,
+          createdAt: item.createdAt ?? null,
+          content: clipDialogSearchText(
+            dialogMessageContentToText(item.content),
+            args.contextClipChars,
+          ),
+        })),
+      };
+    });
+};
+
+export const formatDialogMessageSearchDisplay = (args: {
+  dialogKey: string;
+  query: string;
+  results: DialogMessageSearchResult[];
+}): string => {
+  if (!args.results.length) {
+    return `No original dialog messages matched "${args.query}" in ${args.dialogKey}.`;
+  }
+
+  return [
+    `Found ${args.results.length} message match(es) in ${args.dialogKey} for "${args.query}".`,
+    ...args.results.map((item, index) =>
+      [
+        `Match ${index + 1}: ${item.role ?? "unknown"} id=${item.messageId ?? "unknown"}${item.toolName ? ` tool=${item.toolName}` : ""}`,
+        item.content,
+      ].join("\n")
+    ),
+  ].join("\n\n");
+};