nolo-cli 0.1.30 → 0.1.32

package/ai/tools/readTool.ts

@@ -1,194 +0,0 @@
-// 文件路径: ai/tools/readTool.ts
-
-import { readAction } from "../../database/actions/read";
-import { readAndWaitAction } from "../../database/actions/readAndWait";
-import { slateToSimplifiedMarkdown } from "../../create/editor/transforms/slateToSimplifiedMarkdown";
-import type { PageData } from "../../render/page/types";
-import { getRuntimeServerContext } from "../../database/runtimeServerContext";
-import { isTableMetaKey, rowKey, isAgentKey } from "../../database/keys";
-import { DataType } from "../../create/types";
-import { TableMeta } from "../../render/table/types";
-import { fetchAndSerializeTable } from "../../render/table/utils/tableSerialization";
-import { readFileFunc } from "./readFileTool";
-
-// ---- Types ----
-
-export type ReadArgs = {
-  /**
-   * 对应 database 的 dbKey
-   */
-  dbKey: string;
-
-  /**
-   * 是否等待远程结果：
-   * - false（默认）：使用 readAction，本地优先，远程在后台同步
-   * - true：使用 readAndWaitAction，等待远程与本地决策后返回“权威”结果
-   */
-  waitRemote?: boolean;
-
-  /**
-   * Backward-compatible escape hatch for models that call read with a local
-   * file path even when the readFile tool is available.
-   */
-  filePath?: string;
-  path?: string;
-};
-
-// ---- 工具 Schema，供 LLM 调用 ----
-
-export const readFunctionSchema = {
-  name: "read",
-  description: [
-    "根据指定的 dbKey 从本地/远程数据库读取一条记录。",
-    "支持所有内容类型：",
-    "- page-xxx：页面内容（返回 Markdown）",
-    "- dialog-xxx：对话历史（返回消息列表）",
-    "- agent-xxx：Agent 配置",
-    "- table-xxx：表格数据",
-    "- space-xxx：Space 完整数据（含分类和内容目录）",
-    "行为说明：",
-    "- 默认本地优先：若本地存在则立即返回，后台同步远程；",
-    "- waitRemote=true：等待远程权威结果后返回（适合需要最新数据的场景）。",
-  ].join("\n"),
-  parameters: {
-    type: "object",
-    properties: {
-      dbKey: {
-        type: "string",
-        description: "要读取的数据键，例如 PAGE-xxx、dialog-xxx、agent-xxx、space-xxx。",
-      },
-      waitRemote: {
-        type: "boolean",
-        description:
-          "是否等待远程结果。false=本地优先并在后台同步远程；true=等待远程与本地决策后返回。",
-        default: false,
-      },
-    },
-    required: ["dbKey"],
-  },
-};
-
-// ---- 执行函数 ----
-
-export async function readFunc(
-  args: ReadArgs,
-  thunkApi: any,
-  context?: { parentMessageId?: string; signal?: AbortSignal }
-): Promise<{ rawData: any; displayData?: string }> {
-  const { dbKey, waitRemote = false } = args || {};
-  const localFilePath =
-    typeof args?.filePath === "string"
-      ? args.filePath
-      : typeof args?.path === "string"
-        ? args.path
-        : "";
-
-  if (!dbKey && localFilePath) {
-    const result = await readFileFunc(
-      {
-        filePath: localFilePath,
-        startLine: (args as any).startLine,
-        endLine: (args as any).endLine,
-      },
-      thunkApi,
-      context
-    );
-    return {
-      rawData: result,
-      displayData:
-        typeof result === "string" ? result : JSON.stringify(result, null, 2),
-    };
-  }
-
-  if (!dbKey || typeof dbKey !== "string") {
-    throw new Error("read 工具需要提供字符串类型的 id（dbKey）。");
-  }
-
-  try {
-    const signal = context?.signal;
-
-    const result = waitRemote
-      ? await readAndWaitAction(dbKey, thunkApi)
-      : await readAction({ dbKey, signal }, thunkApi);
-
-    if (!result) {
-      throw new Error(`未找到 dbKey 为 ${dbKey} 的数据。`);
-    }
-
-    // 智能化处理：如果是页面，自动转 Markdown
-    if (dbKey.startsWith("PAGE-") || (result as any).type === DataType.DOC) {
-      const pageData = result as PageData;
-      const markdownContent = slateToSimplifiedMarkdown(pageData.slateData || []);
-
-      return {
-        rawData: {
-          ...pageData,
-          content: markdownContent, // 附加转换后的内容
-        },
-        displayData: `已成功读取页面《${pageData.title}》。\n\n内容预览：\n\n${markdownContent}`,
-      };
-    }
-
-    // 智能化处理：如果是表格，自动转 Markdown
-    if (isTableMetaKey(dbKey) || (result as any).type === DataType.TABLE) {
-      const tableMeta = result as TableMeta;
-      const title = tableMeta.displayName || `Table (${tableMeta.tableId})`;
-
-      // Use shared utility
-      const { rows, markdown: tableMd } = await thunkApi.dispatch(
-        async (_dispatch: any, getState: any, { db }: any) => {
-          const state = getState();
-          const { currentToken: token, remoteServers } =
-            getRuntimeServerContext(state);
-
-          return await fetchAndSerializeTable(tableMeta, db, {
-            token,
-            remoteServers,
-          });
-        }
-      );
-
-      return {
-        rawData: {
-          ...tableMeta,
-          rows,
-          markdown: tableMd,
-        },
-        displayData: `已成功读取表格《${title}》。共 ${rows.length} 行数据。\n\n内容预览：\n\n${tableMd}`,
-      };
-    }
-
-    // 智能化处理：如果是 Agent/Cybot，显示基本信息
-    if (
-      isAgentKey(dbKey) ||
-      (result as any).type === DataType.AGENT ||
-      (result as any).type === DataType.CYBOT
-    ) {
-      const agent = result as any;
-      const name = agent.name || "未命名 Agent";
-      const desc = agent.introduction || agent.description || "无描述";
-      const modelInfo = agent.model ? ` (模型: ${agent.model})` : "";
-
-      return {
-        rawData: agent,
-        displayData: `已成功读取 Agent《${name}》${modelInfo}。\n\n描述：${desc}\n提示词预览：\n${agent.prompt?.slice(0, 200) || "无"
-          }...`,
-      };
-    }
-
-    const sourceLabel = waitRemote
-      ? "已等待远程与本地完成后返回权威结果"
-      : "本地优先，已触发后台与远程同步";
-
-
-    return {
-      rawData: result,
-      displayData: `已读取数据: "${result.dbKey}"（${sourceLabel}）`,
-    };
-  } catch (error: any) {
-    console.error("执行 read 工具时发生错误:", error);
-    throw new Error(
-      `读取数据 (${dbKey}) 失败：${error?.message || String(error)}`
-    );
-  }
-}

package/ai/tools/readXPostTool.ts

@@ -1,233 +0,0 @@
-import { createXReadFailure } from "../../integrations/x-reader/types";
-import type { XPost, XReadResult } from "../../integrations/x-reader/types";
-import { getRequestConfig, ToolApiError } from "./toolApiClient";
-
-export const readXPostFunctionSchema = {
-  name: "read_x_post",
-  description:
-    "读取 X/Twitter status 链接的可见帖子正文、作者和结构化数据。适合用户给出 x.com/twitter.com 帖子链接并要求查看、总结、解释或抽取信息的场景。默认通过桌面本地 Chrome/CDP bridge 读取，不要求用户粘贴 cookie 或 token。",
-  parameters: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        description:
-          "要读取的 X/Twitter status URL，例如 https://x.com/user/status/123。",
-      },
-      keepOpen: {
-        type: "boolean",
-        description: "调试时是否保留临时 Chrome bridge。默认 false。",
-        default: false,
-      },
-      profileDir: {
-        type: "string",
-        description:
-          "桌面端本地 Chrome 专用 profile 目录。用于让用户在本机登录一次 X 后复用本地账号状态；不要传入用户日常 Chrome profile。",
-      },
-      headless: {
-        type: "boolean",
-        description:
-          "是否用 headless 模式启动本地 Chrome。需要用户首次登录本地 X profile 时设为 false 并配合 keepOpen。",
-        default: true,
-      },
-    },
-    required: ["url"],
-  },
-};
-
-type ReadXPostToolContext = {
-  reader?: (
-    url: string,
-    args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
-  ) => Promise<XReadResult<XPost>>;
-};
-
-async function callLocalReadXPostApi(
-  thunkApi: any,
-  body: object,
-): Promise<XReadResult<XPost>> {
-  const { currentServer, token } = getRequestConfig(thunkApi);
-  const browserOrigin = (globalThis as any).window?.location?.origin;
-  const baseUrl = typeof browserOrigin === "string" && browserOrigin
-    ? browserOrigin
-    : currentServer.replace(/\/+$/, "");
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
-  if (token) headers.Authorization = `Bearer ${token}`;
-
-  const response = await fetch(`${baseUrl}/api/read-x-post`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-  });
-  const text = await response.text();
-  let data: any = null;
-  try {
-    data = text ? JSON.parse(text) : null;
-  } catch {
-    data = null;
-  }
-  if (!response.ok) {
-    throw new ToolApiError(
-      data?.error?.message ?? `read_x_post API 请求失败，状态码: ${response.status}`,
-      {
-        status: response.status,
-        code: data?.error?.code,
-        details: data,
-      },
-    );
-  }
-  return data as XReadResult<XPost>;
-}
-
-async function callDesktopReadXPostApi(
-  thunkApi: any,
-  body: object,
-): Promise<XReadResult<XPost>> {
-  const { token } = getRequestConfig(thunkApi);
-  const port = Number(process.env.NOLO_DESKTOP_SERVER_PORT ?? 3233);
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
-  if (token) headers.Authorization = `Bearer ${token}`;
-
-  const response = await fetch(`http://127.0.0.1:${port}/api/read-x-post`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-  });
-  const text = await response.text();
-  let data: any = null;
-  try {
-    data = text ? JSON.parse(text) : null;
-  } catch {
-    data = null;
-  }
-  if (!response.ok) {
-    throw new ToolApiError(
-      data?.error?.message ?? `desktop read_x_post API 请求失败，状态码: ${response.status}`,
-      {
-        status: response.status,
-        code: data?.error?.code,
-        details: data,
-      },
-    );
-  }
-  return data as XReadResult<XPost>;
-}
-
-async function readWithDefaultBridge(
-  url: string,
-  args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
-  thunkApi?: any,
-): Promise<XReadResult<XPost>> {
-  if (process.env.PLATFORM === "web") {
-    if (thunkApi?.getState) {
-      return callLocalReadXPostApi(thunkApi, { url, ...args });
-    }
-
-    if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
-      try {
-        const res = await fetch("/api/read-x-post", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ url, ...args }),
-        });
-        const data = await res.json().catch(() => null);
-        if (res.ok && data) {
-          return data as XReadResult<XPost>;
-        }
-        return createXReadFailure({
-          code: "network_error",
-          message: `desktop read_x_post endpoint failed: HTTP ${res.status}`,
-          nextStep: "请确认桌面端本地服务仍在运行，然后重试。",
-          backend: "desktop_local_browser",
-        });
-      } catch (error) {
-        return createXReadFailure({
-          code: "network_error",
-          message:
-            error instanceof Error
-              ? error.message
-              : "desktop read_x_post endpoint request failed",
-          nextStep: "请确认桌面端本地服务仍在运行，然后重试。",
-          backend: "desktop_local_browser",
-        });
-      }
-    }
-
-    return createXReadFailure({
-      code: "not_connected",
-      message: "read_x_post 需要通过服务器或桌面本地 bridge 执行，不能在普通浏览器 bundle 内直接启动 Chrome/CDP。",
-      nextStep: "请使用服务器 agent run 或桌面端本地 bridge 路径执行该工具。",
-      backend: "desktop_local_browser",
-    });
-  }
-
-  if (process.env.NOLO_DESKTOP === "1" && thunkApi?.getState) {
-    return callDesktopReadXPostApi(thunkApi, { url, ...args });
-  }
-
-  const importBridge = new Function("specifier", "return import(specifier)") as <
-    T = any,
-  >(
-    specifier: string,
-  ) => Promise<T>;
-  const bridgeModuleUrl = new URL(
-    "../../integrations/x-reader/bridge/readXPostWithBridge.ts",
-    import.meta.url,
-  ).href;
-  const { readXPostWithBridge } = await importBridge<{
-    readXPostWithBridge: (
-      url: string,
-      args: { keepOpen?: boolean; profileDir?: string; headless?: boolean },
-    ) => Promise<XReadResult<XPost>>;
-  }>(bridgeModuleUrl);
-  return readXPostWithBridge(url, args);
-}
-
-function assertXStatusUrl(url: string) {
-  if (!/^https?:\/\/(x|twitter)\.com\/[^/]+\/status\/\d+/i.test(url)) {
-    throw new Error("read_x_post 需要一个有效的 X/Twitter status URL。");
-  }
-}
-
-function formatDisplay(result: XReadResult<XPost>) {
-  if (!result.ok) {
-    return [
-      `读取 X 帖子失败：${result.message}`,
-      `失败代码：${result.code}`,
-      result.nextStep ? `下一步：${result.nextStep}` : "",
-      `后端：${result.backend}`,
-    ]
-      .filter(Boolean)
-      .join("\n");
-  }
-
-  const post = result.data;
-  return [
-    `已读取 X 帖子：@${post.author.handle}${post.author.displayName ? `（${post.author.displayName}）` : ""}`,
-    `URL: ${post.url}`,
-    `后端：${result.backend}`,
-    "",
-    post.text,
-  ].join("\n");
-}
-
-export async function readXPostFunc(
-  args: { url: string; keepOpen?: boolean; profileDir?: string; headless?: boolean },
-  thunkApi: any,
-  context: ReadXPostToolContext = {},
-): Promise<{ rawData: XReadResult<XPost>; displayData: string }> {
-  const url = String(args?.url ?? "").trim();
-  assertXStatusUrl(url);
-
-  const keepOpen = Boolean(args?.keepOpen);
-  const profileDir = String(args?.profileDir ?? "").trim() || undefined;
-  const headless = args?.headless;
-  const rawData =
-    (await context.reader?.(url, { keepOpen, profileDir, headless })) ??
-    (await readWithDefaultBridge(url, { keepOpen, profileDir, headless }, thunkApi));
-
-  return {
-    rawData,
-    displayData: formatDisplay(rawData),
-  };
-}

package/ai/tools/rememberMemoryTool.ts

@@ -1,84 +0,0 @@
-import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
-import { callToolApi } from "./toolApiClient";
-import type { RememberMemoryScope } from "../memory/remember";
-import type { MemoryKind } from "../memory/types";
-
-export interface RememberMemoryToolArgs {
-  content: string;
-  scope?: RememberMemoryScope;
-  kind?: MemoryKind;
-}
-
-export const rememberMemoryFunctionSchema = {
-  name: "rememberMemory",
-  description: [
-    "当你判断某条用户偏好、纠正、决策习惯或当前 Space 共识值得被长期记住时，调用本工具写入一条 memory。",
-    "默认先记原始事件，不要把一次性临时要求、当前任务进度或明显短期信息写进去。",
-    "只有重复出现的可执行流程/排障步骤才传 kind=procedural；一般偏好和事实保持默认 episodic。",
-    "只有当当前 dialog 明确绑定了一个 Space，且这条内容确实属于共享协作共识时，才应该传 scope=space。",
-    "优先写成一句简洁、未来仍可理解的话；如无必要，不要频繁调用。",
-  ].join("\n"),
-  parameters: {
-    type: "object",
-    properties: {
-      content: {
-        type: "string",
-        description:
-          "要记住的内容。请写成一句未来仍然可理解的简洁描述，例如“这个用户在复杂问题里更喜欢先看结论”。",
-      },
-      scope: {
-        type: "string",
-        enum: ["auto", "user", "space"],
-        description:
-          "记忆范围。默认 auto：优先记到当前用户；若没有用户上下文再退到当前 space。只有当前 dialog 明确绑定了 space，且你明确想写共享协作记忆时才传 space；否则保持 auto。",
-      },
-      kind: {
-        type: "string",
-        enum: ["episodic", "semantic", "procedural"],
-        description:
-          "记忆类型。默认 episodic。只有重复出现的可执行流程、排障步骤或稳定 runbook 才使用 procedural。",
-      },
-    },
-    required: ["content"],
-  } as const,
-};
-
-export async function rememberMemoryFunc(
-  args: RememberMemoryToolArgs,
-  thunkApi: any
-): Promise<{ rawData: unknown; displayData: string }> {
-  const state = thunkApi.getState();
-  const spaceId = selectCurrentSpaceId(state) || undefined;
-  const content = String(args.content ?? "").trim();
-  const scope = args.scope ?? "auto";
-  const kind = args.kind ?? "episodic";
-
-  if (!content) {
-    throw new Error("rememberMemory 需要非空 content。");
-  }
-
-  const result = await callToolApi<{
-    success: boolean;
-    content: string;
-    requestedScope: RememberMemoryScope;
-    resolvedScopes: Array<{ ownerType: string; ownerId: string }>;
-  }>(
-    thunkApi,
-    "/api/memory/remember",
-    {
-      content,
-      scope,
-      kind,
-      spaceId,
-    },
-    { withAuth: true }
-  );
-
-  const scopeLabel =
-    result.resolvedScopes?.[0]?.ownerType === "space" ? "当前空间" : "当前用户";
-
-  return {
-    rawData: result,
-    displayData: `已记住这条${scopeLabel}记忆。`,
-  };
-}

package/ai/tools/remotionVideoTool.ts

@@ -1,151 +0,0 @@
-import { ContentType } from "../../app/types";
-import { addContentAction } from "../../create/space/content/addContentAction";
-import { selectCurrentSpaceId } from "../../create/space/spaceSlice";
-import { buildDatabaseFileContentUrl } from "../../database/fileUrl";
-import { fileKey } from "../../database/keys";
-import { selectCurrentServer } from "../../app/settings/settingSlice";
-import { selectUserId } from "../../auth/authSlice";
-import { callToolApi } from "./toolApiClient";
-
-type RemotionRenderVideoArgs = {
-  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;
-};
-
-export const remotionRenderVideoFunctionSchema = {
-  name: "remotionRenderVideo",
-  description: [
-    "使用平台内 Remotion 模板渲染产品视频，并保存为可复用 MP4 文件。",
-    "",
-    "适用场景：",
-    "- 用户要生成手机传播视频、产品介绍视频、欢迎页短片、Agent/AI 工作流演示视频。",
-    "- 需要把文案、标题、输入框示例等参数化后产出 MP4。",
-    "",
-    "当前模板：",
-    "- mobile-product: 9:16 竖版，适合手机传播。",
-    "- landscape-product: 16:9 横版，适合官网/演示页。",
-    "- 兼容旧别名 nolo-mobile-product / nolo-landscape-product。",
-  ].join("\n"),
-  parameters: {
-    type: "object",
-    properties: {
-      template: {
-        type: "string",
-        enum: ["mobile-product", "landscape-product", "nolo-mobile-product", "nolo-landscape-product"],
-        description: "视频模板。默认 mobile-product。",
-      },
-      brand: {
-        type: "string",
-        description: "品牌名，例如 Nolo.Chat、你的产品名、店铺名或活动名。",
-      },
-      hook: {
-        type: "string",
-        description: "竖版视频首屏钩子标题，例如“把一句想法，推进成结果”。",
-      },
-      headline: {
-        type: "string",
-        description: "横版视频主标题；竖版缺少 hook 时也会作为 hook 使用。",
-      },
-      subline: {
-        type: "string",
-        description: "横版视频副标题。",
-      },
-      prompt: {
-        type: "string",
-        description: "手机输入框里逐字打出的示例需求。",
-      },
-      cta: {
-        type: "string",
-        description: "结尾行动号召，例如“开始体验”。",
-      },
-      outputName: {
-        type: "string",
-        description: "输出文件名，建议以 .mp4 结尾。",
-      },
-    },
-  },
-};
-
-export const remotionRenderVideoFunc = async (
-  args: RemotionRenderVideoArgs,
-  thunkApi: any
-): Promise<{ rawData: any; displayData: string; llmContext?: string }> => {
-  const result: any = await callToolApi(
-    thunkApi,
-    "/api/remotion/render",
-    {
-      template: args.template || "mobile-product",
-      brand: args.brand,
-      hook: args.hook,
-      headline: args.headline,
-      subline: args.subline,
-      prompt: args.prompt,
-      cta: args.cta,
-      outputName: args.outputName,
-    },
-    { withAuth: true }
-  );
-
-  const state = thunkApi.getState();
-  const userId = selectUserId(state);
-  const spaceId = selectCurrentSpaceId(state);
-  const currentServer = selectCurrentServer(state);
-  const fileId = result?.fileId;
-  const metadata = result?.metadata || {};
-  const fileDbKey = userId && fileId ? fileKey.single(userId, fileId) : "";
-  const url = buildDatabaseFileContentUrl(currentServer, fileDbKey || fileId);
-
-  if (spaceId && fileDbKey) {
-    try {
-      await addContentAction(
-        {
-          spaceId,
-          contentKey: fileDbKey,
-          title: metadata.originalName || "Remotion video.mp4",
-          type: ContentType.FILE,
-          fileCategory: "video",
-        } as any,
-        { dispatch: thunkApi.dispatch, getState: thunkApi.getState }
-      );
-    } catch (error) {
-      console.warn("[remotionRenderVideoFunc] Failed to add video to space:", error);
-    }
-  }
-
-  const displayLines = [
-    result?.text || "已使用 Remotion 生成视频。",
-    fileId ? `- fileId: ${fileId}` : "",
-    fileDbKey ? `- fileDbKey: ${fileDbKey}` : "",
-    url ? `- url: ${url}` : "",
-    metadata?.size ? `- size: ${metadata.size} bytes` : "",
-    result?.template ? `- template: ${result.template}` : "",
-  ].filter(Boolean);
-
-  const llmContext = [
-    "The Remotion video tool produced a reusable video file.",
-    "Reuse these exact references when mentioning or embedding the video:",
-    fileId ? `- fileId: ${fileId}` : "",
-    fileDbKey ? `- fileDbKey: ${fileDbKey}` : "",
-    url ? `- url: ${url}` : "",
-    metadata?.originalName ? `- name: ${metadata.originalName}` : "",
-    result?.template ? `- template: ${result.template}` : "",
-  ]
-    .filter(Boolean)
-    .join("\n");
-
-  return {
-    rawData: {
-      ...result,
-      fileDbKey,
-      url,
-    },
-    displayData: displayLines.join("\n"),
-    llmContext,
-  };
-};