nolo-cli 0.1.31 → 0.1.32

package/server/handlers/favoriteHandlers.ts

@@ -1,423 +0,0 @@
-// server/api/favoriteHandlers.ts
-
-import { getServerAuthorityStore } from "../../database/server/db";
-import {
-  createFavoriteKey,
-  createFavoriteStatsKey,
-} from "../../database/keys";
-import { writeStoreOps } from "../../database/server/storeBatchCompat";
-import { isTombstoneRecord } from "../../database/tombstones";
-
-import type { ApiContext, ApiError } from "../api/types";
-
-import { parseToken } from "../../auth/token";
-import type { Agent } from "../../app/types";
-import {
-  FavoriteTargetType,
-  ToggleFavoriteParams,
-  ToggleFavoriteResult,
-  SetFavoriteParams,
-  SetFavoriteResult,
-  ListFavoritesParams,
-  ListFavoritesResult,
-} from "../../app/favorite/type";
-
-const getFavoriteStore = () => getServerAuthorityStore();
-
-function toTimeMs(t: unknown) {
-  if (typeof t === "number") return t;
-  const n = Date.parse(String(t ?? 0));
-  return Number.isFinite(n) ? n : 0;
-}
-
-/**
- * 从 token 中解析 userId
- */
-async function getUserIdFromToken(token?: string): Promise<string> {
-  if (!token) {
-    const err: ApiError = {
-      code: "unauthorized",
-      message: "Authentication required",
-    };
-    throw err;
-  }
-
-  try {
-    const payload = parseToken(token);
-    if (!payload?.userId) {
-      const err: ApiError = {
-        code: "unauthorized",
-        message: "Invalid token payload",
-      };
-      throw err;
-    }
-    return payload.userId;
-  } catch {
-    const err: ApiError = {
-      code: "unauthorized",
-      message: "Invalid token",
-    };
-    throw err;
-  }
-}
-
-async function getUserIdFromContext(context: ApiContext): Promise<string> {
-  if (context.userId) return context.userId;
-  return getUserIdFromToken(context.token);
-}
-
-/**
- * 针对不同 targetType 解析收藏 key / stats key / 目标对象 key（按 key 存）
- * content/doc 在底层映射到 page（可承载 page/meta/image 等 key）。
- */
-function resolveFavoriteKeysByKey(
-  targetType: FavoriteTargetType,
-  userId: string,
-  targetKey: string
-) {
-  const normalizedTargetType =
-    targetType === "doc" || targetType === "content" ? "page" : targetType;
-
-  switch (normalizedTargetType) {
-    case "agent":
-      return {
-        // 收藏关系键：fav-agent-key-{userId}-{agentKey}
-        relKey: createFavoriteKey.agentByKey(userId, targetKey),
-        // 反向键：fav-agent-key-by-agent-{agentKey}-{userId}
-        reverseRelKey: createFavoriteKey.agentByKeyReverse(targetKey, userId),
-        // 统计键：fav-agent-count-key-{agentKey}
-        statsKey: createFavoriteStatsKey.agentByKey(targetKey),
-        // 目标对象键：就是 agentKey 本身
-        targetKey,
-        normalizedTargetType,
-      };
-
-    case "page":
-      return {
-        relKey: createFavoriteKey.pageByKey(userId, targetKey),
-        reverseRelKey: createFavoriteKey.pageByKeyReverse(targetKey, userId),
-        statsKey: createFavoriteStatsKey.pageByKey(targetKey),
-        targetKey,
-        normalizedTargetType,
-      };
-
-    case "file":
-      // TODO: 如需支持 file 收藏，在这里补充 key 解析逻辑。
-      throw new Error(`Favorite for '${targetType}' not implemented yet`);
-
-    default:
-      throw new Error(`Unsupported targetType: ${targetType}`);
-  }
-}
-
-/** 安全 get：不存在时返回 undefined，而不是抛错 */
-async function safeGet<T>(key: string): Promise<T | undefined> {
-  const serverDb = getFavoriteStore();
-  try {
-    const record = await serverDb.get(key);
-    return isTombstoneRecord(record) ? undefined : record;
-  } catch {
-    return undefined;
-  }
-}
-
-function buildFavoriteResult(
-  targetType: FavoriteTargetType,
-  targetKey: string,
-  isFavorite: boolean,
-  favoriteCount: number
-): ToggleFavoriteResult {
-  return {
-    targetType,
-    targetKey,
-    isFavorite,
-    favoriteCount: Math.max(0, favoriteCount),
-  };
-}
-
-async function setFavoriteState(
-  targetType: FavoriteTargetType,
-  targetKey: string,
-  userId: string,
-  desiredFavoriteState: boolean,
-  favoritedAt?: number
-): Promise<ToggleFavoriteResult> {
-  const serverDb = getFavoriteStore();
-  const resolved = resolveFavoriteKeysByKey(targetType, userId, targetKey);
-  const {
-    relKey,
-    reverseRelKey,
-    statsKey,
-    targetKey: resolvedTargetKey,
-    normalizedTargetType,
-  } = resolved;
-  const existed = !!(await safeGet(relKey));
-  const stats = (await safeGet<{ count: number }>(statsKey)) ?? { count: 0 };
-  const currentCount = typeof stats.count === "number" ? stats.count : 0;
-
-  if (desiredFavoriteState === existed) {
-    return buildFavoriteResult(
-      targetType,
-      resolvedTargetKey,
-      desiredFavoriteState,
-      currentCount
-    );
-  }
-
-  const nextCount = desiredFavoriteState
-    ? currentCount + 1
-    : Math.max(0, currentCount - 1);
-  const ops: Array<
-    { type: "put"; key: string; value: any } | { type: "del"; key: string }
-  > = desiredFavoriteState
-    ? [
-        {
-          type: "put",
-          key: relKey,
-          value: {
-            userId,
-            targetKey: resolvedTargetKey,
-            targetType: normalizedTargetType,
-            createdAt:
-              typeof favoritedAt === "number" && Number.isFinite(favoritedAt)
-                ? favoritedAt
-                : Date.now(),
-          },
-        },
-        { type: "put", key: statsKey, value: { count: nextCount } },
-      ]
-    : [
-        { type: "del", key: relKey },
-        { type: "put", key: statsKey, value: { count: nextCount } },
-      ];
-
-  if (reverseRelKey) {
-    ops.push(
-      desiredFavoriteState
-        ? { type: "put", key: reverseRelKey, value: true }
-        : { type: "del", key: reverseRelKey }
-    );
-  }
-
-  if (normalizedTargetType === "agent") {
-    const agent = await safeGet<Agent>(resolvedTargetKey);
-    if (agent) {
-      const oldMetrics =
-        agent.metrics && typeof agent.metrics === "object" ? agent.metrics : {};
-      ops.push({
-        type: "put",
-        key: resolvedTargetKey,
-        value: {
-          ...agent,
-          metrics: {
-            ...oldMetrics,
-            favoriteCount: nextCount,
-          },
-        },
-      });
-    }
-  }
-
-  await writeStoreOps(serverDb, ops);
-
-  return buildFavoriteResult(
-    targetType,
-    resolvedTargetKey,
-    desiredFavoriteState,
-    nextCount
-  );
-}
-
-/**
- * RPC: toggleFavorite
- *
- * - 当前实现 targetType = "agent" | "content" | "page" | "doc"
- * - targetKey = 对应对象完整 dbKey（例如 "agent-xxx" / "page-xxx" / "meta-xxx" / "image-xxx"）
- *
- * TODO:
- *  - 并发下（多 tab/多设备同时点），stats.count 可能会出现小概率漂移。
- *    如果将来要严格精确计数，可以：
- *      1) 在这里加乐观锁/CAS，保证更新原子性；
- *      2) 或定期从关系表全表重算 stats，进行矫正。
- */
-export async function toggleFavorite(
-  params: ToggleFavoriteParams,
-  context: ApiContext
-): Promise<ToggleFavoriteResult> {
-  const { targetType, targetKey } = params;
-  const userId = await getUserIdFromContext(context);
-  const { relKey } = resolveFavoriteKeysByKey(targetType, userId, targetKey);
-  const existed = !!(await safeGet(relKey));
-
-  return setFavoriteState(targetType, targetKey, userId, !existed);
-}
-
-/** RPC: setFavorite（幂等收藏写入，供多站点同步使用） */
-export async function setFavorite(
-  params: SetFavoriteParams,
-  context: ApiContext
-): Promise<SetFavoriteResult> {
-  const { targetType, targetKey, isFavorite, favoritedAt } = params;
-  const userId = await getUserIdFromContext(context);
-
-  return setFavoriteState(
-    targetType,
-    targetKey,
-    userId,
-    isFavorite,
-    favoritedAt
-  );
-}
-
-type ListableFavoriteTargetType = Extract<
-  FavoriteTargetType,
-  "agent" | "content" | "page" | "doc" | "file"
->;
-
-const LISTABLE_FAVORITE_TARGET_TYPES = new Set<ListableFavoriteTargetType>([
-  "agent",
-  "content",
-  "page",
-  "doc",
-  "file",
-]);
-
-function normalizeListFavoriteTargetTypes(
-  targetType: ListFavoritesParams["targetType"]
-): ListableFavoriteTargetType[] {
-  if (Array.isArray(targetType)) {
-    return targetType.filter(
-      (value): value is ListableFavoriteTargetType =>
-        typeof value === "string" &&
-        LISTABLE_FAVORITE_TARGET_TYPES.has(value as ListableFavoriteTargetType)
-    );
-  }
-
-  if (
-    typeof targetType === "string" &&
-    LISTABLE_FAVORITE_TARGET_TYPES.has(targetType as ListableFavoriteTargetType)
-  ) {
-    return [targetType as ListableFavoriteTargetType];
-  }
-
-  return [];
-}
-
-async function listFavoritesForUser(
-  targetType: ListableFavoriteTargetType,
-  userId: string
-): Promise<ListFavoritesResult> {
-  const serverDb = getFavoriteStore();
-  const normalizedTargetType =
-    targetType === "doc" || targetType === "content" ? "page" : targetType;
-
-  switch (normalizedTargetType) {
-    case "agent": {
-      const { start, end } = createFavoriteKey.agentKeyRangeOfUser(userId);
-      const prefix = start; // "fav-agent-key-{userId}-"
-      const items: { id: string; favoritedAt: number }[] = [];
-      const MAX_FAVORITES = 500;
-
-      for await (const [key, value] of serverDb.iterator({ gte: start, lte: end })) {
-        if (!key.startsWith(prefix)) continue;
-        const agentKey = key.slice(prefix.length);
-
-        if (agentKey) {
-          const agent = await serverDb.get(agentKey).catch(() => null);
-          if (agent && !isTombstoneRecord(agent)) {
-            items.push({
-              id: agentKey,
-              favoritedAt: toTimeMs((value as any)?.createdAt),
-            });
-          } else {
-            await serverDb.del(key);
-            const reverseKey = createFavoriteKey.agentByKeyReverse(agentKey, userId);
-            await serverDb.del(reverseKey);
-          }
-        }
-        if (items.length >= MAX_FAVORITES) break;
-      }
-
-      items.sort((a, b) => b.favoritedAt - a.favoritedAt);
-
-      return {
-        targetType,
-        ids: items.map((i) => i.id),
-        items,
-      };
-    }
-
-    case "page": {
-      const { start, end } = createFavoriteKey.pageKeyRangeOfUser(userId);
-      const prefix = start; // "fav-page-key-{userId}-"
-      const items: { id: string; favoritedAt: number }[] = [];
-      const MAX_FAVORITES = 500;
-
-      for await (const [key, value] of serverDb.iterator({ gte: start, lte: end })) {
-        if (!key.startsWith(prefix)) continue;
-        const pageKey = key.slice(prefix.length);
-
-        if (pageKey) {
-          const page = await serverDb.get(pageKey).catch(() => null);
-          if (page && !isTombstoneRecord(page)) {
-            items.push({
-              id: pageKey,
-              favoritedAt: toTimeMs((value as any)?.createdAt),
-            });
-          } else {
-            await serverDb.del(key);
-            const reverseKey = createFavoriteKey.pageByKeyReverse(pageKey, userId);
-            await serverDb.del(reverseKey);
-          }
-        }
-        if (items.length >= MAX_FAVORITES) break;
-      }
-
-      items.sort((a, b) => b.favoritedAt - a.favoritedAt);
-
-      return {
-        targetType,
-        ids: items.map((i) => i.id),
-        items,
-      };
-    }
-
-    case "file":
-      throw new Error(`listFavorites for '${targetType}' not implemented yet`);
-
-    default:
-      throw new Error(`Unsupported targetType: ${targetType}`);
-  }
-}
-
-/**
- * RPC: listFavorites
- *
- * - 当前实现 targetType = "agent" | "content" | "page" | "doc"
- * - 返回当前用户收藏的该类型对象的 key 列表
- *
- * TODO:
- *  - 如果未来收藏数量很多，可以增加分页/游标支持，而不是一次性返回所有 ids。
- */
-export async function listFavorites(
-  params: ListFavoritesParams,
-  context: ApiContext
-): Promise<ListFavoritesResult | ListFavoritesResult[]> {
-  const { targetType } = params;
-  const userId = await getUserIdFromContext(context);
-  const requestedTargetTypes = normalizeListFavoriteTargetTypes(targetType);
-
-  if (requestedTargetTypes.length === 0) {
-    throw new Error("Unsupported targetType");
-  }
-
-  if (requestedTargetTypes.length === 1) {
-    return listFavoritesForUser(requestedTargetTypes[0], userId);
-  }
-
-  return Promise.all(
-    requestedTargetTypes.map((requestedTargetType) =>
-      listFavoritesForUser(requestedTargetType, userId)
-    )
-  );
-}

package/server/handlers/fetchWebpageHandler.ts

@@ -1,117 +0,0 @@
-// 文件路径: handlers/fetchWebpageHandler.ts
-import { authenticateRequest } from "../../auth/utils";
-
-export const handleFetchWebpage = async (req: Request): Promise<Response> => {
-  const headers = {
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "POST, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type, Authorization",
-    "Access-Control-Max-Age": "86400",
-    "Content-Type": "application/json",
-  };
-
-  if (req.method === "OPTIONS") {
-    return new Response(null, { status: 204, headers });
-  }
-
-  const auth = await authenticateRequest(req);
-  if (auth instanceof Response) return auth;
-
-  try {
-    const body = await req.json();
-    const { url } = body;
-
-    if (!url || typeof url !== "string") {
-      return new Response(JSON.stringify({ error: "URL 参数是必需的" }), {
-        status: 400,
-        headers,
-      });
-    }
-
-    // SSRF 防护：只允许公网 HTTP/HTTPS，拒绝内网/回环地址
-    let parsedUrl: URL;
-    try {
-      parsedUrl = new URL(url);
-    } catch {
-      return new Response(JSON.stringify({ error: "无效的 URL 格式" }), {
-        status: 400,
-        headers,
-      });
-    }
-    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-      return new Response(JSON.stringify({ error: "仅支持 HTTP/HTTPS 协议" }), {
-        status: 400,
-        headers,
-      });
-    }
-    const hostname = parsedUrl.hostname.toLowerCase();
-    const BLOCKED = /^(localhost|127\.|10\.|172\.(1[6-9]|2\d|3[01])\.|192\.168\.|::1|0\.0\.0\.0|169\.254\.)/;
-    if (BLOCKED.test(hostname)) {
-      return new Response(JSON.stringify({ error: "不允许访问内网地址" }), {
-        status: 403,
-        headers,
-      });
-    }
-
-    const response = await fetch(url, {
-      headers: {
-        "Accept": "text/markdown, text/html, application/xhtml+xml, */*",
-        "User-Agent": "NoloBot/1.0 (AI Agent; +https://nolo.ai)"
-      }
-    });
-
-    const contentType = response.headers.get("content-type") || "";
-    const content = await response.text();
-
-    let cleanedContent: string;
-    if (contentType.includes("text/markdown")) {
-      // 如果已经是 Markdown，直接使用，仅做简单修剪
-      cleanedContent = content.trim();
-    } else {
-      // 如果是 HTML 或其他，执行清理逻辑
-      cleanedContent = cleanHtmlForAI(content);
-    }
-
-    // 限制工具返回体，避免整页内容在多轮 agent 对话中反复回灌造成高 token 开销
-    const previewLength = 1200;
-    const maxContentLength = 12 * 1024;
-    const previewContent =
-      cleanedContent.length > previewLength
-        ? cleanedContent.substring(0, previewLength) + "...（预览内容已截断）"
-        : cleanedContent;
-    const fullContent =
-      cleanedContent.length > maxContentLength
-        ? cleanedContent.substring(0, maxContentLength) +
-        "...（完整内容已截断）"
-        : cleanedContent;
-
-    return new Response(
-      JSON.stringify({
-        preview: previewContent,
-        fullContent: fullContent,
-        contentType: contentType, // 告知前端实际拿到的类型
-        markdownTokens: response.headers.get("x-markdown-tokens") // 透传 Cloudflare 的 token 统计
-      }),
-      {
-        status: 200,
-        headers,
-      }
-    );
-  } catch (error: any) {
-    return new Response(JSON.stringify({ error: error.message }), {
-      status: 500,
-      headers,
-    });
-  }
-};
-
-// 伪代码：清理 HTML 内容
-function cleanHtmlForAI(html: string): string {
-  // 去除 script, style 等标签
-  return html
-    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
-    .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "")
-    .replace(/<[^>]*>/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-}

package/server/handlers/fileOutlineHandler.ts

@@ -1,107 +0,0 @@
-// 文件路径: packages/server/handlers/fileOutlineHandler.ts
-
-import { resolve, sep } from "node:path";
-import ts from "typescript";
-
-export interface SymbolInfo {
-    name: string;
-    kind: string;
-    line: number;
-    endLine: number;
-    isExported: boolean;
-}
-
-const JSON_HEADERS = {
-    "Content-Type": "application/json; charset=utf-8",
-};
-
-function resolvePathUnderProjectRoot(
-    filePath: string
-): { absPath: string; projectRoot: string } {
-    const projectRoot = process.cwd();
-    const absPath = resolve(projectRoot, filePath);
-
-    const normalizedRoot = projectRoot.endsWith(sep)
-        ? projectRoot
-        : projectRoot + sep;
-    if (!absPath.startsWith(normalizedRoot)) {
-        throw new Error("非法 filePath：必须位于项目根目录内。");
-    }
-
-    return { absPath, projectRoot };
-}
-
-export async function extractFileSymbols(absPath: string): Promise<SymbolInfo[]> {
-    const file = Bun.file(absPath);
-    if (!(await file.exists())) return [];
-
-    // 仅针对 JS/TS 相关文件使用 TS Parser
-    if (!/\.(js|jsx|ts|tsx)$/.test(absPath)) {
-        return [];
-    }
-
-    const content = await file.text();
-    const sourceFile = ts.createSourceFile(absPath, content, ts.ScriptTarget.Latest, true);
-    const symbols: SymbolInfo[] = [];
-
-    function visit(node: ts.Node) {
-        let name: string | undefined;
-        let kind: string | undefined;
-
-        if (ts.isFunctionDeclaration(node)) {
-            name = node.name?.getText();
-            kind = "function";
-        } else if (ts.isClassDeclaration(node)) {
-            name = node.name?.getText();
-            kind = "class";
-        } else if (ts.isInterfaceDeclaration(node)) {
-            name = node.name?.getText();
-            kind = "interface";
-        } else if (ts.isTypeAliasDeclaration(node)) {
-            name = node.name?.getText();
-            kind = "type";
-        } else if (ts.isEnumDeclaration(node)) {
-            name = node.name?.getText();
-            kind = "enum";
-        } else if (ts.isMethodDeclaration(node) || ts.isMethodSignature(node)) {
-            name = node.name?.getText();
-            kind = "method";
-        } else if (ts.isVariableStatement(node)) {
-            // 对于变量语句，我们可能想要列出其中的所有声明
-            for (const decl of node.declarationList.declarations) {
-                const dName = decl.name.getText();
-                const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-                const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-                symbols.push({
-                    name: dName,
-                    kind: "variable",
-                    line: start.line + 1,
-                    endLine: end.line + 1,
-                    isExported: !!(ts.getCombinedModifierFlags(node as any) & ts.ModifierFlags.Export)
-                });
-            }
-            // 变量已经处理过了，不再通过通用逻辑处理
-            ts.forEachChild(node, visit);
-            return;
-        }
-
-        if (name && kind) {
-            const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-            const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-            symbols.push({
-                name,
-                kind,
-                line: start.line + 1,
-                endLine: end.line + 1,
-                isExported: !!(ts.getCombinedModifierFlags(node as any) & ts.ModifierFlags.Export)
-            });
-        }
-
-        ts.forEachChild(node, visit);
-    }
-
-    visit(sourceFile);
-    return symbols.sort((a, b) => a.line - b.line);
-}
-
-