nolo-cli 0.1.26 → 0.1.29

package/server/handlers/rememberMemoryHandler.ts

@@ -0,0 +1,69 @@
+import { authenticateRequest, CORS_HEADERS_AUTH } from "../../auth/utils";
+import { rememberMemory, type RememberMemoryScope } from "../../ai/memory/remember";
+import type { MemoryKind } from "../../ai/memory/types";
+
+const json = (data: any, status = 200): Response =>
+  new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS_AUTH },
+  });
+
+export async function handleRememberMemory(req: Request): Promise<Response> {
+  if (req.method === "OPTIONS") {
+    return new Response(null, { status: 204, headers: CORS_HEADERS_AUTH });
+  }
+
+  const auth = await authenticateRequest(req);
+  if (auth instanceof Response) return auth;
+
+  let body: {
+    content?: string;
+    scope?: RememberMemoryScope;
+    kind?: MemoryKind;
+    dialogId?: string;
+    spaceId?: string;
+  };
+  try {
+    body = await req.json();
+  } catch {
+    return json(
+      {
+        error: {
+          message: "请求体必须是合法的 JSON",
+          code: "INVALID_JSON",
+        },
+      },
+      400
+    );
+  }
+
+  try {
+    const result = await rememberMemory({
+      userId: auth.userId,
+      spaceId: typeof body.spaceId === "string" ? body.spaceId.trim() || null : null,
+      dialogId: typeof body.dialogId === "string" ? body.dialogId.trim() || null : null,
+      content: typeof body.content === "string" ? body.content : "",
+      scope: body.scope ?? "auto",
+      kind: body.kind,
+    });
+    return json(result);
+  } catch (error: any) {
+    const message =
+      typeof error?.message === "string" ? error.message : "Failed to remember memory";
+    const status =
+      message.includes("content is required") ||
+      message.includes("requires ") ||
+      message.includes("kind must be")
+        ? 400
+        : 500;
+    return json(
+      {
+        error: {
+          message,
+          code: status === 400 ? "INVALID_REMEMBER_MEMORY" : "REMEMBER_MEMORY_FAILED",
+        },
+      },
+      status
+    );
+  }
+}

package/server/handlers/remotionRenderHandler.ts

@@ -0,0 +1,236 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { authenticateRequest, CORS_HEADERS_AUTH } from "../../auth/utils";
+import { saveBufferAsFile } from "../../database/server/fileService";
+
+type RemotionRenderRequest = {
+  template?: "mobile-product" | "landscape-product" | "nolo-mobile-product" | "nolo-landscape-product";
+  brand?: string;
+  hook?: string;
+  headline?: string;
+  subline?: string;
+  prompt?: string;
+  cta?: string;
+  outputName?: string;
+};
+
+const JSON_HEADERS = {
+  "Content-Type": "application/json; charset=utf-8",
+  ...CORS_HEADERS_AUTH,
+};
+
+const TEMPLATE_TO_COMPOSITION = {
+  "mobile-product": "NoloMobileProductDemo",
+  "landscape-product": "NoloRemotionDemo",
+  "nolo-mobile-product": "NoloMobileProductDemo",
+  "nolo-landscape-product": "NoloRemotionDemo",
+} as const;
+
+const TEMPLATE_TO_OUTPUT = {
+  "mobile-product": "mobile-product-video.mp4",
+  "landscape-product": "product-video.mp4",
+  "nolo-mobile-product": "nolo-mobile-product-demo.mp4",
+  "nolo-landscape-product": "nolo-product-demo.mp4",
+} as const;
+
+const json = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+
+const sanitizeFileName = (value: string): string =>
+  value
+    .replace(/[\\/:*?"<>|]+/g, "-")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 80) || "remotion-video.mp4";
+
+const truncate = (value: unknown, fallback: string, max = 220): string => {
+  const text = typeof value === "string" ? value.trim() : "";
+  return (text || fallback).slice(0, max);
+};
+
+const buildProps = (body: RemotionRenderRequest, template: keyof typeof TEMPLATE_TO_COMPOSITION) => {
+  if (template === "mobile-product" || template === "nolo-mobile-product") {
+    return {
+      brand: truncate(body.brand, "Nolo.Chat", 48),
+      hook: truncate(body.hook || body.headline, "把一句想法，推进成结果", 48),
+      prompt: truncate(
+        body.prompt,
+        "帮我把欢迎页做成一个适合手机传播的产品视频。",
+        160
+      ),
+      cta: truncate(body.cta, "开始体验", 32),
+    };
+  }
+
+  return {
+    brand: truncate(body.brand, "Nolo.Chat", 48),
+    headline: truncate(body.headline || body.hook, "你只需像平常一样聊天", 72),
+    subline: truncate(
+      body.subline,
+      "在屏幕背后，AI 协调记忆、Agent 和创作工具，把想法推进成结果。",
+      140
+    ),
+    prompt: truncate(
+      body.prompt,
+      "帮我把这个想法做成一个能展示、能修改、明早能验收的版本。",
+      160
+    ),
+    cta: truncate(body.cta, "开始体验", 32),
+  };
+};
+
+const runRemotionRender = async (params: {
+  composition: string;
+  props: Record<string, unknown>;
+  outputPath: string;
+}) => {
+  const demoDir = resolve(process.cwd(), "packages", "remotion-demo");
+  const entry = join(demoDir, "src", "index.ts");
+  const remotionCli = resolve(
+    process.cwd(),
+    "node_modules",
+    "@remotion",
+    "cli",
+    "remotion-cli.js"
+  );
+  const propsPath = join(
+    resolve(process.cwd(), "data", "remotion-renders"),
+    `${Date.now()}-${params.composition}-props.json`
+  );
+
+  await writeFile(propsPath, JSON.stringify(params.props), "utf8");
+
+  try {
+    const proc = Bun.spawn(
+      [
+        "node",
+        remotionCli,
+        "render",
+        entry,
+        params.composition,
+        params.outputPath,
+        `--props=${propsPath}`,
+      ],
+      {
+        cwd: demoDir,
+        stdin: "ignore",
+        stdout: "pipe",
+        stderr: "pipe",
+        env: {
+          ...process.env,
+          NO_COLOR: "1",
+        },
+      }
+    );
+
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      throw new Error(
+        [
+          `Remotion render failed with exit code ${exitCode}.`,
+          stdout.trim() ? `[stdout]\n${stdout.trim()}` : "",
+          stderr.trim() ? `[stderr]\n${stderr.trim()}` : "",
+        ]
+          .filter(Boolean)
+          .join("\n\n")
+      );
+    }
+
+    return { stdout, stderr, exitCode };
+  } finally {
+    await rm(propsPath, { force: true }).catch(() => undefined);
+  }
+};
+
+export async function handleRemotionRender(req: Request): Promise<Response> {
+  try {
+    const auth = await authenticateRequest(req);
+    if (auth instanceof Response) return auth;
+
+    const body = (await req.json().catch(() => null)) as RemotionRenderRequest | null;
+    if (!body || typeof body !== "object") {
+      return json({ error: { message: "请求体必须是 JSON 对象。", code: "INVALID_BODY" } }, 400);
+    }
+
+    const template =
+      body.template === "landscape-product" || body.template === "nolo-landscape-product"
+        ? body.template
+        : body.template === "nolo-mobile-product"
+          ? body.template
+          : "mobile-product";
+    const composition = TEMPLATE_TO_COMPOSITION[template];
+    const props = buildProps(body, template);
+    const outputName = sanitizeFileName(
+      body.outputName || TEMPLATE_TO_OUTPUT[template]
+    );
+
+    const outDir = resolve(process.cwd(), "data", "remotion-renders");
+    await mkdir(outDir, { recursive: true });
+    const outputPath = join(outDir, `${Date.now()}-${outputName}`);
+
+    const renderLog = await runRemotionRender({
+      composition,
+      props,
+      outputPath,
+    });
+
+    const buffer = await readFile(outputPath);
+    const { fileId, metadata } = await saveBufferAsFile(buffer, {
+      tenantId: auth.userId,
+      originalName: outputName.endsWith(".mp4") ? outputName : `${outputName}.mp4`,
+      mimeType: "video/mp4",
+      ownerType: "user",
+      ownerId: auth.userId,
+      uploadedBy: auth.userId,
+      source: "ai-generated",
+      model: "remotion",
+      prompt: JSON.stringify(props),
+      tags: ["ai-generated", "remotion", "video", template],
+      clientMetadata: {
+        fileCategory: "video",
+        template,
+        composition,
+      },
+    });
+
+    await rm(outputPath, { force: true }).catch(() => undefined);
+
+    const fileDbKey = `file-${auth.userId}-${fileId}`;
+    const url = `/api/v1/db/file/content/${fileDbKey}`;
+
+    return json({
+      ok: true,
+      text: `已使用 Remotion 生成视频：${metadata.originalName}`,
+      template,
+      composition,
+      props,
+      fileId,
+      fileDbKey,
+      url,
+      metadata,
+      renderLog: {
+        exitCode: renderLog.exitCode,
+        stdoutTail: renderLog.stdout.slice(-2000),
+        stderrTail: renderLog.stderr.slice(-2000),
+      },
+    });
+  } catch (error) {
+    console.error("[remotion-render] failed:", error);
+    return json(
+      {
+        ok: false,
+        error: {
+          message: error instanceof Error ? error.message : String(error),
+          code: "REMOTION_RENDER_FAILED",
+        },
+      },
+      500
+    );
+  }
+}

package/server/handlers/renderMarkdownHandler.ts

@@ -0,0 +1,66 @@
+const JSON_HEADERS = {
+  "Content-Type": "application/json; charset=utf-8",
+};
+
+const MAX_MARKDOWN_LENGTH = 200_000;
+let reactDomServerPromise: Promise<typeof import("react-dom/server")> | null = null;
+
+function loadReactDomServer() {
+  if (!reactDomServerPromise) {
+    reactDomServerPromise = import("react-dom/server").catch((error) => {
+      reactDomServerPromise = null;
+      throw error;
+    });
+  }
+  return reactDomServerPromise;
+}
+
+type RenderMarkdownRequest = {
+  markdown?: unknown;
+};
+
+function json(status: number, body: Record<string, unknown>) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: JSON_HEADERS,
+  });
+}
+
+export async function handleRenderMarkdown(req: Request): Promise<Response> {
+  let body: RenderMarkdownRequest;
+
+  try {
+    body = (await req.json()) as RenderMarkdownRequest;
+  } catch {
+    return json(400, { error: "Invalid JSON body." });
+  }
+
+  const markdown = typeof body.markdown === "string" ? body.markdown : "";
+  if (!markdown.trim()) {
+    return json(400, { error: "markdown is required." });
+  }
+
+  if (markdown.length > MAX_MARKDOWN_LENGTH) {
+    return json(413, { error: "markdown is too large." });
+  }
+
+  try {
+    const { renderToString } = await loadReactDomServer();
+    const html = renderToString(
+      Bun.markdown.react(markdown, undefined, {
+        reactVersion: 19,
+        autolinks: true,
+        headings: { ids: true },
+        noHtmlBlocks: true,
+        noHtmlSpans: true,
+        tagFilter: true,
+      })
+    );
+
+    return json(200, { html });
+  } catch (error) {
+    return json(500, {
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}

package/server/handlers/revenueShareReportHandler.ts

@@ -0,0 +1,96 @@
+import { getBillingLedgerRuntime } from "../../auth/server/ledger";
+import type { RevenueShareReportStore } from "../../auth/server/revenueShareReport";
+import { buildRevenueShareReport } from "../../auth/server/revenueShareReport";
+
+const JSON_HEADERS = {
+  "content-type": "application/json; charset=utf-8",
+};
+
+type RevenueShareReportEnv = NodeJS.ProcessEnv & {
+  BILLING_LEDGER_AUDIT_SECRET?: string;
+  BILLING_LEDGER_CLUSTER_ID?: string;
+};
+
+const json = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+
+const parseOptionalTimestamp = (value: string | null) => {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) return Number(trimmed);
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`invalid timestamp: ${value}`);
+  }
+  return parsed;
+};
+
+const parseSinceHours = (value: string | null) => {
+  if (!value) return 24;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`invalid sinceHours: ${value}`);
+  }
+  return parsed;
+};
+
+const resolveDefaultStore = async (): Promise<RevenueShareReportStore> => {
+  const dbModule = await import("../../database/server/db");
+  return dbModule.default as RevenueShareReportStore;
+};
+
+export function createRevenueShareReportHandler({
+  store,
+  env = process.env,
+  nowMs,
+}: {
+  store?: RevenueShareReportStore;
+  env?: Partial<RevenueShareReportEnv>;
+  nowMs?: number;
+} = {}) {
+  return async function handleRevenueShareReport(req: Request) {
+    const expectedSecret = String(env.BILLING_LEDGER_AUDIT_SECRET || "").trim();
+    if (!expectedSecret) {
+      return new Response("Not Found", { status: 404 });
+    }
+
+    const providedSecret =
+      req.headers.get("x-billing-ledger-audit-secret")?.trim() || "";
+    if (providedSecret !== expectedSecret) {
+      return json({ success: false, error: "Unauthorized" }, 401);
+    }
+
+    try {
+      const url = new URL(req.url);
+      const now = nowMs ?? Date.now();
+      const untilMs = parseOptionalTimestamp(url.searchParams.get("until")) ?? now;
+      const explicitSince = parseOptionalTimestamp(url.searchParams.get("since"));
+      const sinceMs =
+        explicitSince ?? untilMs - parseSinceHours(url.searchParams.get("sinceHours")) * 3600_000;
+      const clusterId =
+        url.searchParams.get("cluster")?.trim() ||
+        getBillingLedgerRuntime({ ...process.env, ...env }).clusterId;
+
+      const report = await buildRevenueShareReport({
+        store: store ?? (await resolveDefaultStore()),
+        clusterId,
+        sinceMs,
+        untilMs,
+        nowMs: now,
+      });
+
+      return json({ success: true, report });
+    } catch (error) {
+      return json(
+        {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        400
+      );
+    }
+  };
+}
+
+export const handleRevenueShareReport = createRevenueShareReportHandler();

package/server/handlers/searchRepoHandler.ts

@@ -0,0 +1,159 @@
+// 文件路径: packages/server/handlers/searchRepoHandler.ts
+
+import { resolve, relative, sep } from "node:path";
+
+type SearchRepoRequestBody = {
+    query: string;
+    pathScope?: string;
+    maxResults?: number;
+    contextLines?: number;
+};
+
+const JSON_HEADERS = { "Content-Type": "application/json; charset=utf-8" };
+const ROOT = process.cwd();
+const SEARCH_REPO_PREVIEW_MAX_CHARS = 240;
+const EXCLUDE_DIRS = ["node_modules", ".git", "dist", "build", ".next", ".gemini", "node_modules_copy"];
+const EXCLUDE_GLOBS = ["*.map", "*.min.js", "*.bundle.js"];
+
+export function shouldExcludeSearchRepoPath(relPath: string): boolean {
+    const normalized = relPath.replace(/\\/g, "/");
+    return normalized.startsWith("public/assets/")
+        || normalized.endsWith(".map")
+        || normalized.endsWith(".min.js")
+        || normalized.endsWith(".bundle.js");
+}
+
+export function truncateSearchRepoPreview(
+    preview: string,
+    maxChars: number = SEARCH_REPO_PREVIEW_MAX_CHARS,
+): string {
+    const normalized = preview.replace(/\s+/g, " ").trim();
+    if (normalized.length <= maxChars) return normalized;
+    return `${normalized.slice(0, maxChars)}… [truncated]`;
+}
+
+function resolvePathUnderRoot(pathScope: string): string {
+    const absRoot = ROOT.endsWith(sep) ? ROOT : `${ROOT}${sep}`;
+    const absPath = resolve(ROOT, pathScope || ".");
+    if (!absPath.startsWith(absRoot) && absPath !== ROOT) {
+        throw new Error("pathScope 必须位于项目根目录内");
+    }
+    return absPath;
+}
+
+function parsePositiveInt(value: unknown, fallback: number): number {
+    if (value === undefined || value === null) return fallback;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error("maxResults 必须是正整数");
+    }
+    return value;
+}
+
+export async function handleSearchRepo(req: Request): Promise<Response> {
+    try {
+        if (req.method !== "POST") {
+            return new Response(JSON.stringify({ error: "Method not allowed" }), {
+                status: 405,
+                headers: { ...JSON_HEADERS, "Allow": "POST, OPTIONS" },
+            });
+        }
+
+        let body: unknown;
+        try {
+            body = await req.json();
+        } catch {
+            return new Response(JSON.stringify({ error: "请求体必须是合法的 JSON。" }), { status: 400, headers: JSON_HEADERS });
+        }
+
+        const { query, pathScope = ".", maxResults }: Partial<SearchRepoRequestBody> =
+            typeof body === "object" && body !== null ? (body as any) : {};
+
+        if (!query || typeof query !== "string") {
+            return new Response(JSON.stringify({ error: "必须提供有效的 query 字符串。" }), { status: 400, headers: JSON_HEADERS });
+        }
+
+        let absSearchRoot: string;
+        try {
+            absSearchRoot = resolvePathUnderRoot(pathScope);
+        } catch (e: any) {
+            return new Response(
+                JSON.stringify({ error: e?.message || "pathScope 参数无效" }),
+                { status: 400, headers: JSON_HEADERS }
+            );
+        }
+        const safeMaxResults = Math.min(parsePositiveInt(maxResults, 20), 200);
+
+        const args = [
+            "-rnIi",
+            ...EXCLUDE_DIRS.map((d) => `--exclude-dir=${d}`),
+            ...EXCLUDE_GLOBS.map((pattern) => `--exclude=${pattern}`),
+            "--",
+            query,
+            absSearchRoot,
+        ];
+
+        let grepOut = "";
+        try {
+            const proc = Bun.spawn(["grep", ...args], {
+                cwd: ROOT,
+                stdout: "pipe",
+                stderr: "pipe",
+                stdin: "ignore",
+            });
+            const [stdout, exitCode] = await Promise.all([
+                new Response(proc.stdout).text(),
+                proc.exited,
+            ]);
+            // grep: 0=有匹配, 1=无匹配
+            if (exitCode <= 1) {
+                grepOut = stdout;
+            }
+        } catch {
+            // grep 失败时返回空结果，避免暴露系统细节
+        }
+
+        const lines = grepOut.trim().split("\n").filter(l => !!l);
+        const hits: any[] = [];
+
+        for (const line of lines) {
+            if (hits.length >= safeMaxResults) break;
+
+            // grep 输出格式: /path/to/file:line:content
+            const firstColon = line.indexOf(":");
+            const secondColon = line.indexOf(":", firstColon + 1);
+            if (firstColon < 0 || secondColon < 0) continue;
+
+            const absPath = line.slice(0, firstColon);
+            const lineNo = parseInt(line.slice(firstColon + 1, secondColon), 10);
+            const preview = line.slice(secondColon + 1).trim();
+
+            if (isNaN(lineNo)) continue;
+
+            try {
+                const relPath = relative(ROOT, absPath);
+                if (shouldExcludeSearchRepoPath(relPath)) continue;
+
+                // 获取该文件总行数（可选）
+                // 为了性能，如果不要求 contextLines，我们就不读整个文件了。
+                hits.push({
+                    path: relPath,
+                    line: lineNo,
+                    preview: truncateSearchRepoPreview(preview),
+                });
+            } catch {
+                // 忽略解析错误
+            }
+        }
+
+        return new Response(JSON.stringify({
+            ok: true,
+            query,
+            hits,
+            totalHits: lines.length >= safeMaxResults ? `${safeMaxResults}+` : lines.length
+        }), { status: 200, headers: JSON_HEADERS });
+
+    } catch (error: any) {
+        console.error("[search-repo] Error:", error);
+        return new Response(JSON.stringify({ error: `searchRepo 失败：${error?.message || String(error)}` }), { status: 500, headers: JSON_HEADERS });
+    }
+}

package/server/handlers/tableAccess.ts

@@ -0,0 +1,34 @@
+import { metaKey } from "../../database/keys";
+import serverDb from "../../database/server/db";
+import type { TableMeta } from "../../render/table/types";
+import { hasSpaceRole } from "./appSpaceAccess";
+
+export async function canReadTableRows(params: {
+  userId: string | null | undefined;
+  tenantId: string;
+  tableId: string;
+  tableMeta?: TableMeta | null;
+}): Promise<boolean> {
+  const { userId, tenantId, tableId } = params;
+  if (!userId || !tenantId || !tableId) return false;
+  if (userId === tenantId) return true;
+
+  const tableMeta =
+    params.tableMeta ??
+    ((await serverDb.get(metaKey(tenantId, tableId)).catch(() => null)) as TableMeta | null);
+  const spaceId = typeof tableMeta?.spaceId === "string" ? tableMeta.spaceId.trim() : "";
+  if (!spaceId) return false;
+
+  return hasSpaceRole(userId, spaceId, "guest");
+}
+
+export async function assertCanReadTableRows(params: {
+  userId: string | null | undefined;
+  tenantId: string;
+  tableId: string;
+  tableMeta?: TableMeta | null;
+}) {
+  if (!(await canReadTableRows(params))) {
+    throw new Error("Forbidden: table row reads require table owner or space membership");
+  }
+}