nolo-cli 0.1.23 → 0.1.29

package/server/handlers/publicHandler.ts

@@ -0,0 +1,209 @@
+// packages/server/handlers/publicHandler.ts
+
+import { file as bunFile } from "bun";
+import { isProduction } from "../../app/utils/env";
+import { maybeCompressResponse } from "../httpCompression";
+import { resolvePublicPath } from "../publicPaths";
+
+const STATIC_CACHE_HEADERS: Record<string, string> = { "Cache-Control": "no-cache" };
+const PUBLIC_ART_CACHE_HEADERS: Record<string, string> = {
+    "Cache-Control": "public, max-age=86400, stale-while-revalidate=604800",
+};
+const ONE_YEAR_IMMUTABLE_CACHE_HEADERS: Record<string, string> = {
+    "Cache-Control": "public, max-age=31536000, immutable",
+};
+const ARTIFACT_RUNTIME_CORS_HEADERS: Record<string, string> = {
+    "Access-Control-Allow-Origin": "*",
+    "Cross-Origin-Resource-Policy": "cross-origin",
+};
+const DEFAULT_DESKTOP_DOWNLOAD_PUBLIC_BASE =
+    "https://pub-3ddccf44847b43ae84d0164260638c7b.r2.dev";
+const REDIRECTED_DESKTOP_DOWNLOAD_RE =
+    /^downloads\/(?:(?:stable|canary)-[^/]+\.(?:exe|dmg|tar\.zst|zip|json|patch)|desktop-release-manifest\.json)$/i;
+
+const PUBLIC_ART_FILES = new Set([
+    "fankuan-mountains.jpg",
+    "friedrich-wanderer.jpg",
+    "guoxi-spring.jpg",
+    "hiroshige-plum.jpg",
+    "hiroshige-snow.jpg",
+    "hokusai-fuji.jpg",
+    "hokusai-thunder.jpg",
+    "hokusai-wave.jpg",
+    "millais-ophelia.jpg",
+    "monet-waterlilies.jpg",
+    "nizan-gentlemen.jpg",
+    "tangyin-landscape.jpg",
+    "turner-temeraire.jpg",
+    "vermeer-milkmaid.jpg",
+    "wangximeng-rivers.jpg",
+]);
+
+const MIME_BY_EXT: Record<string, string> = {
+    ".js": "text/javascript; charset=utf-8",
+    ".mjs": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".json": "application/json; charset=utf-8",
+    ".txt": "text/plain; charset=utf-8",
+    ".xml": "application/xml; charset=utf-8",
+};
+
+const getMimeType = (path: string, bunMime: string) => {
+    if (bunMime) return bunMime;
+    const dot = path.lastIndexOf(".");
+    if (dot < 0) return "application/octet-stream";
+    return MIME_BY_EXT[path.slice(dot).toLowerCase()] || "application/octet-stream";
+};
+
+const acceptsEncoding = (req: Request, encoding: "br" | "gzip") =>
+    (req.headers.get("accept-encoding") ?? "")
+        .toLowerCase()
+        .split(",")
+        .map((part) => part.trim().split(";")[0])
+        .includes(encoding);
+
+const appendVary = (headers: Record<string, string>, value: string) => {
+    const current = headers.Vary ?? headers.vary;
+    if (!current) {
+        headers.Vary = value;
+        return;
+    }
+
+    const values = current.split(",").map((part) => part.trim().toLowerCase());
+    if (!values.includes(value.toLowerCase())) {
+        headers.Vary = `${current}, ${value}`;
+    }
+};
+
+const selectPrecompressedVariant = async (req: Request, normalized: string) => {
+    if (acceptsEncoding(req, "br")) {
+        const brFile = bunFile(resolvePublicPath(`${normalized}.br`));
+        if (await brFile.exists()) return { file: brFile, encoding: "br" };
+    }
+
+    if (acceptsEncoding(req, "gzip")) {
+        const gzipFile = bunFile(resolvePublicPath(`${normalized}.gz`));
+        if (await gzipFile.exists()) return { file: gzipFile, encoding: "gzip" };
+    }
+
+    return null;
+};
+
+const resolveMigratedDesktopDownloadUrl = (normalized: string): string | null => {
+    if (!REDIRECTED_DESKTOP_DOWNLOAD_RE.test(normalized)) return null;
+    const base = (
+        process.env.DESKTOP_DOWNLOAD_PUBLIC_BASE?.trim() ||
+        DEFAULT_DESKTOP_DOWNLOAD_PUBLIC_BASE
+    ).replace(/\/+$/, "");
+    const fileName = normalized.slice("downloads/".length);
+    return `${base}/${encodeURIComponent(fileName)}`;
+};
+
+export const handlePublicRequest = async (req: Request): Promise<Response> => {
+    const url = new URL(req.url);
+    const filePath = url.pathname.substring("/public/".length);
+    const normalized = filePath.replace(/^\/+/, "");
+
+    const isDev = !isProduction;
+
+    const isDevHashedChunk =
+        isDev &&
+        filePath.startsWith("assets/chunks/") &&
+        /-[A-Z0-9]{8,}\.js$/i.test(filePath);
+
+    const isDevHashedAsset =
+        isDev &&
+        filePath.startsWith("assets/assets/") &&
+        /-[A-Z0-9]{8,}\.[a-z0-9]+$/i.test(filePath);
+
+    const isDevEntry =
+        isDev &&
+        (filePath === "assets/entry.js" ||
+            filePath === "assets/entry.css" ||
+            filePath === "assets/artifactRuntime.js") &&
+        url.searchParams.has("v");
+
+    const isProdHashedAsset =
+        isProduction &&
+        (/^assets\/(?:entry|artifactRuntime)-[A-Z0-9]{8,}\.js$/i.test(filePath) ||
+            /^assets\/entry-[A-Z0-9]{8,}\.css$/i.test(filePath) ||
+            /^assets\/chunks\/.+-[A-Z0-9]{8,}\.js$/i.test(filePath) ||
+            /^assets\/assets\/.+-[A-Z0-9]{8,}\.[a-z0-9]+$/i.test(filePath));
+
+    const isVersionedProdLocale =
+        isProduction &&
+        /^locales\/[^/]+\.json$/i.test(filePath) &&
+        url.searchParams.has("v");
+
+    const isPublicArt =
+        PUBLIC_ART_FILES.has(normalized) ||
+        PUBLIC_ART_FILES.has(normalized.replace(/-900(?=\.jpe?g$)/i, ""));
+
+    const headers: Record<string, string> =
+        isDevHashedChunk || isDevHashedAsset || isDevEntry || isProdHashedAsset || isVersionedProdLocale
+            ? { ...ONE_YEAR_IMMUTABLE_CACHE_HEADERS }
+            : isPublicArt
+              ? { ...PUBLIC_ART_CACHE_HEADERS }
+            : { ...STATIC_CACHE_HEADERS };
+    if (filePath.startsWith("assets/")) {
+        Object.assign(headers, ARTIFACT_RUNTIME_CORS_HEADERS);
+    }
+
+    if (!normalized || normalized.includes("..")) {
+        return new Response("Not Found", { status: 404 });
+    }
+
+    const migratedDesktopDownloadUrl = resolveMigratedDesktopDownloadUrl(normalized);
+    if (migratedDesktopDownloadUrl) {
+        return Response.redirect(migratedDesktopDownloadUrl, 302);
+    }
+
+    const file = bunFile(resolvePublicPath(normalized));
+
+    if (!(await file.exists())) {
+        return new Response("Not Found", { status: 404 });
+    }
+
+    try {
+        const stat = await file.stat();
+        const etag = `"${stat.size}-${stat.mtimeMs}"`;
+        const lastModified = stat.mtime.toUTCString();
+
+        headers.ETag = etag;
+        headers["Last-Modified"] = lastModified;
+
+        const ifNoneMatch = req.headers.get("if-none-match");
+        const ifModifiedSince = req.headers.get("if-modified-since");
+
+        if (ifNoneMatch === etag || ifModifiedSince === lastModified) {
+            return new Response(null, {
+                status: 304,
+                headers,
+            });
+        }
+
+        const precompressed = isProdHashedAsset
+            ? await selectPrecompressedVariant(req, normalized)
+            : null;
+        const responseFile = precompressed?.file ?? file;
+        const responseStat = precompressed ? await responseFile.stat() : stat;
+
+        headers["Content-Type"] = getMimeType(normalized, file.type);
+        headers["Content-Length"] = String(responseStat.size);
+
+        if (precompressed) {
+            headers["Content-Encoding"] = precompressed.encoding;
+            appendVary(headers, "Accept-Encoding");
+            return new Response(req.method === "HEAD" ? null : responseFile.stream(), { headers });
+        }
+
+        const bytes = await file.bytes();
+
+        return maybeCompressResponse(req, new Response(bytes, { headers }));
+    } catch (error) {
+        console.error("读取静态资源失败", { path: normalized, error });
+        return new Response("Not Found", { status: 404 });
+    }
+};

package/server/handlers/readFileHandler.ts

@@ -0,0 +1,300 @@
+// 文件路径: packages/server/handlers/readFileHandler.ts
+
+import {
+    getDefaultDevToolAllowedRoots,
+    resolveDevToolPathWithinRoots,
+    resolveProjectFilePath,
+} from "../devToolPathPolicy";
+import { extractFileSymbols, type SymbolInfo } from "./fileOutlineHandler";
+
+type ReadFileRequestBody = {
+    filePath: string;
+    startLine?: number;
+    endLine?: number;
+};
+
+const JSON_HEADERS = {
+    "Content-Type": "application/json; charset=utf-8",
+};
+
+async function fileExists(path: string): Promise<boolean> {
+    // 使用 Bun 的 API 检查文件是否存在
+    return await Bun.file(path).exists();
+}
+
+function parseOptionalPositiveInt(
+    value: unknown,
+    name: string
+): number | undefined {
+    if (value === undefined || value === null) return undefined;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw new Error(`读取文件失败：${name} 必须是正整数。`);
+    }
+    return value;
+}
+
+function resolveReadablePath(filePath: string): string {
+    if (process.env.NOLO_DESKTOP === "1") {
+        return resolveDevToolPathWithinRoots(filePath, getDefaultDevToolAllowedRoots());
+    }
+    return resolveProjectFilePath(filePath);
+}
+
+export function resolveSymbolBoundary(
+    symbols: SymbolInfo[],
+    endLine: number,
+    isLineEmpty: boolean
+): { adjustedEndLine: number; nextSymbol?: { name: string; kind: string; line: number } } {
+    let adjustedEndLine = endLine;
+    let containingSymbol: SymbolInfo | undefined;
+    let nextSymbol: SymbolInfo | undefined;
+
+    // 情况 3 & 4：如果已经是符号末尾或者是空行，则不扩展
+    const isAtBoundary = symbols.some(s => s.endLine === endLine);
+    if (isAtBoundary || isLineEmpty) {
+        // 仅寻找下一个符号
+        for (const symbol of symbols) {
+            if (symbol.line > endLine) {
+                if (!nextSymbol || symbol.line < nextSymbol.line) {
+                    nextSymbol = symbol;
+                }
+            }
+        }
+        return {
+            adjustedEndLine,
+            nextSymbol: nextSymbol ? { name: nextSymbol.name, kind: nextSymbol.kind, line: nextSymbol.line } : undefined
+        };
+    }
+
+    for (const symbol of symbols) {
+        // 核心逻辑：找到满足 symbol.line <= endLine < symbol.endLine 的符号
+        if (symbol.line <= endLine && endLine < symbol.endLine) {
+            // 取跨度最小的（处理嵌套）
+            if (!containingSymbol || (symbol.endLine - symbol.line < containingSymbol.endLine - containingSymbol.line)) {
+                containingSymbol = symbol;
+            }
+        }
+
+        if (symbol.line > endLine) {
+            if (!nextSymbol || symbol.line < nextSymbol.line) {
+                nextSymbol = symbol;
+            }
+        }
+    }
+
+    if (containingSymbol) {
+        adjustedEndLine = containingSymbol.endLine;
+    }
+
+    // 重新校准 nextSymbol，确保它在 adjustedEndLine 之后
+    if (adjustedEndLine > endLine) {
+        nextSymbol = undefined;
+        for (const symbol of symbols) {
+            if (symbol.line > adjustedEndLine) {
+                if (!nextSymbol || symbol.line < nextSymbol.line) {
+                    nextSymbol = symbol;
+                }
+            }
+        }
+    }
+
+    return {
+        adjustedEndLine,
+        nextSymbol: nextSymbol ? { name: nextSymbol.name, kind: nextSymbol.kind, line: nextSymbol.line } : undefined
+    };
+}
+
+export async function handleReadFile(req: Request): Promise<Response> {
+    try {
+        let body: unknown;
+        try {
+            body = await req.json();
+        } catch {
+            return new Response(
+                JSON.stringify({ error: "请求体必须是合法的 JSON。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        const { filePath, startLine, endLine }: Partial<ReadFileRequestBody> =
+            typeof body === "object" && body !== null ? (body as any) : {};
+
+        if (!filePath || typeof filePath !== "string") {
+            return new Response(
+                JSON.stringify({
+                    error: "读取文件失败：必须提供有效的 filePath 字符串。",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        let parsedStartLine: number | undefined;
+        let parsedEndLine: number | undefined;
+        try {
+            parsedStartLine = parseOptionalPositiveInt(startLine, "startLine");
+            parsedEndLine = parseOptionalPositiveInt(endLine, "endLine");
+        } catch (err: any) {
+            return new Response(
+                JSON.stringify({ error: err?.message || "读取文件失败：参数无效。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+        if (
+            parsedStartLine !== undefined &&
+            parsedEndLine !== undefined &&
+            parsedStartLine > parsedEndLine
+        ) {
+            return new Response(
+                JSON.stringify({
+                    error: "读取文件失败：startLine 不能大于 endLine。",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        // 简单防御：不允许明显是目录的路径
+        if (filePath.endsWith("/") || filePath.endsWith("\\")) {
+            return new Response(
+                JSON.stringify({
+                    error: "读取文件失败：filePath 不能是目录路径。",
+                }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        let absPath: string;
+        try {
+            absPath = resolveReadablePath(filePath);
+        } catch (err: any) {
+            return new Response(
+                JSON.stringify({ error: err?.message || "解析文件路径失败。" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+
+        const exists = await fileExists(absPath);
+
+        if (!exists) {
+            return new Response(
+                JSON.stringify({
+                    error: "读取文件失败：目标文件不存在。",
+                    filePath,
+                }),
+                { status: 404, headers: JSON_HEADERS }
+            );
+        }
+
+        // 使用 Bun 的 API 读取整个文件内容（文本）
+        const rawContent = await Bun.file(absPath).text();
+
+        // 统一换行符为 \n，方便行号计算和行级编辑
+        const content =
+            rawContent.indexOf("\r\n") >= 0
+                ? rawContent.replace(/\r\n/g, "\n")
+                : rawContent;
+
+        const lines = content === "" ? [] : content.split("\n");
+        const totalLineCount = lines.length;
+
+        if (totalLineCount === 0) {
+            const result = {
+                ok: true,
+                filePath,
+                absolutePath: absPath,
+                content: "",
+                lineCount: 0,
+                totalLineCount: 0,
+                lineOffset: 1,
+                rangeStart: 1,
+                rangeEnd: 0,
+            };
+
+            return new Response(JSON.stringify(result), {
+                status: 200,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        let rangeStart = parsedStartLine ?? 1;
+        let rangeEnd = parsedEndLine ?? totalLineCount;
+
+        let adjustedEndLine = rangeEnd;
+        let nextSymbol: { name: string; kind: string; line: number } | undefined;
+
+        // 只有在明确指定了 endLine 且文件可能是代码文件时才进行自动扩展
+        if (parsedEndLine !== undefined && /\.(js|jsx|ts|tsx)$/.test(absPath)) {
+            try {
+                const symbols = await extractFileSymbols(absPath);
+                const isLineEmpty = lines[rangeEnd - 1]?.trim() === "";
+                const boundary = resolveSymbolBoundary(symbols, rangeEnd, isLineEmpty);
+                adjustedEndLine = boundary.adjustedEndLine;
+                nextSymbol = boundary.nextSymbol;
+
+                if (adjustedEndLine > totalLineCount) {
+                    adjustedEndLine = totalLineCount;
+                }
+                rangeEnd = adjustedEndLine;
+            } catch (err) {
+                // 静默降级
+                console.error("[read-file] Symbol extraction failed:", err);
+            }
+        }
+
+        if (rangeStart > totalLineCount) {
+            const result = {
+                ok: true,
+                filePath,
+                absolutePath: absPath,
+                content: "",
+                lineCount: totalLineCount,
+                totalLineCount,
+                lineOffset: totalLineCount + 1,
+                rangeStart: totalLineCount + 1,
+                rangeEnd: totalLineCount,
+            };
+
+            return new Response(JSON.stringify(result), {
+                status: 200,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        if (rangeEnd > totalLineCount) {
+            rangeEnd = totalLineCount;
+        }
+
+        const rangeLines = lines.slice(rangeStart - 1, rangeEnd);
+        const rangeContent = rangeLines.join("\n");
+
+        const result = {
+            ok: true,
+            filePath,
+            absolutePath: absPath,
+            content: rangeContent,
+            lineCount: totalLineCount,
+            totalLineCount,
+            lineOffset: rangeStart,
+            rangeStart,
+            rangeEnd,
+            adjustedEndLine,
+            nextSymbol,
+        };
+
+
+        return new Response(JSON.stringify(result), {
+            status: 200,
+            headers: JSON_HEADERS,
+        });
+    } catch (error: any) {
+        console.error("[read-file] Error:", error);
+        return new Response(
+            JSON.stringify({
+                error: `读取文件失败：${error?.message || String(error)}`,
+            }),
+            {
+                status: 500,
+                headers: JSON_HEADERS,
+            }
+        );
+    }
+}

package/server/handlers/readXPostHandler.ts

@@ -0,0 +1,180 @@
+import { authenticateRequest } from "../../auth/utils";
+import { readXPostFunc } from "../../ai/tools/readXPostTool";
+import { spawn } from "node:child_process";
+
+const DEFAULT_READ_TIMEOUT_MS = 30000;
+const MAX_READ_TIMEOUT_MS = 60000;
+
+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",
+};
+
+function resolveTimeoutMs(value: unknown) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_READ_TIMEOUT_MS;
+  }
+  return Math.min(Math.floor(parsed), MAX_READ_TIMEOUT_MS);
+}
+
+async function withReadTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          reject(
+            Object.assign(
+              new Error(`read_x_post timed out after ${timeoutMs}ms`),
+              { code: "READ_X_POST_TIMEOUT" },
+            ),
+          );
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+function parseChildJson(stdout: string) {
+  const line = stdout
+    .split(/\r?\n/)
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .findLast((item) => item.startsWith("{") && item.endsWith("}"));
+  if (!line) {
+    throw Object.assign(new Error("read_x_post child did not return JSON"), {
+      code: "READ_X_POST_CHILD_FAILED",
+    });
+  }
+  return JSON.parse(line);
+}
+
+async function readXPostInDesktopChild(
+  body: any,
+  timeoutMs: number,
+) {
+  const entry = process.env.NOLO_DESKTOP_APP_ENTRY;
+  if (!entry) {
+    throw Object.assign(new Error("NOLO_DESKTOP_APP_ENTRY is not configured."), {
+      code: "READ_X_POST_CHILD_FAILED",
+    });
+  }
+
+  return await new Promise<any>((resolve, reject) => {
+    const child = spawn(process.execPath, [entry], {
+      env: {
+        ...process.env,
+        NOLO_X_READER_CHILD_REQUEST: Buffer.from(
+          JSON.stringify({
+            url: body?.url,
+            keepOpen: body?.keepOpen,
+            profileDir: body?.profileDir,
+            headless: body?.headless,
+          }),
+        ).toString("base64"),
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      settled = true;
+      child.kill();
+      reject(
+        Object.assign(new Error(`read_x_post timed out after ${timeoutMs}ms`), {
+          code: "READ_X_POST_TIMEOUT",
+        }),
+      );
+    }, timeoutMs);
+
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      try {
+        resolve(parseChildJson(stdout));
+      } catch (error: any) {
+        reject(
+          Object.assign(
+            new Error(
+              `${error?.message ?? "read_x_post child failed"}${stderr ? `: ${stderr.slice(0, 500)}` : ""}`,
+            ),
+            { code: error?.code ?? (code === 0 ? "READ_X_POST_CHILD_FAILED" : "READ_X_POST_FAILED") },
+          ),
+        );
+      }
+    });
+  });
+}
+
+export const handleReadXPost = async (req: Request): Promise<Response> => {
+  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().catch(() => ({}));
+    const timeoutMs = resolveTimeoutMs(body?.timeoutMs);
+    const rawData = process.env.NOLO_DESKTOP === "1" && process.env.NOLO_DESKTOP_APP_ENTRY
+      ? await readXPostInDesktopChild(body, timeoutMs)
+      : (
+        await withReadTimeout(
+          readXPostFunc(
+            {
+              url: body?.url,
+              keepOpen: body?.keepOpen,
+              profileDir: body?.profileDir,
+              headless: body?.headless,
+            },
+            null,
+          ),
+          timeoutMs,
+        )
+      ).rawData;
+
+    return new Response(JSON.stringify(rawData), {
+      status: 200,
+      headers,
+    });
+  } catch (error: any) {
+    return new Response(
+      JSON.stringify({
+        error: {
+          message: error?.message ?? String(error),
+          code: error?.code ?? "READ_X_POST_FAILED",
+        },
+      }),
+      {
+        status: error?.code === "READ_X_POST_TIMEOUT" ? 504 : 500,
+        headers,
+      },
+    );
+  }
+};