nolo-cli 0.1.40 → 0.1.42

package/ai/tools/table/shareTableTool.ts

@@ -0,0 +1,148 @@
+import { DataType } from "../../../create/types";
+import { readAndWait } from "../../../database/dbSlice";
+import { shareResourceAction } from "../../../share/action";
+import { hasExplicitPublicShareRequest } from "../../../share/publicSharePolicy";
+import { selectAllMsgs, selectCurrentDialogId } from "../../../chat/messages/messageSlice";
+
+type ShareTableArgs = {
+  dbKey?: string;
+  tenantId?: string;
+  tableId?: string;
+  title?: string;
+  description?: string;
+  visibility?: "private" | "community";
+};
+
+type ShareTableResult = {
+  rawData: {
+    token: string;
+    key: string;
+    url: string;
+  };
+  displayData: string;
+};
+
+export const shareTableFunctionSchema = {
+  name: "shareTable",
+  description:
+    "把一张表发布为分享链接。默认用于社区分享；只有当用户明确要求公开/社区分享时才应调用。",
+  parameters: {
+    type: "object",
+    properties: {
+      dbKey: {
+        type: "string",
+        description: "表 meta 记录的 dbKey，例如 meta-user123-table123。",
+      },
+      tenantId: {
+        type: "string",
+        description: "表所属租户 ID。dbKey 缺失时必填。",
+      },
+      tableId: {
+        type: "string",
+        description: "表 ID。dbKey 缺失时必填。",
+      },
+      title: {
+        type: "string",
+        description: "分享标题；不传则回退为表 ID。",
+      },
+      description: {
+        type: "string",
+        description: "可选：分享描述。",
+      },
+      visibility: {
+        type: "string",
+        enum: ["private", "community"],
+        description: "默认 community。",
+      },
+    },
+  },
+};
+
+const resolveTableDbKey = (args: ShareTableArgs): string => {
+  if (typeof args.dbKey === "string" && args.dbKey.trim()) {
+    return args.dbKey.trim();
+  }
+  if (
+    typeof args.tenantId === "string" &&
+    args.tenantId.trim() &&
+    typeof args.tableId === "string" &&
+    args.tableId.trim()
+  ) {
+    return `meta-${args.tenantId.trim()}-${args.tableId.trim()}`;
+  }
+  throw new Error("shareTable 需要提供 dbKey，或同时提供 tenantId 和 tableId。");
+};
+
+const asNonEmptyString = (value: unknown): string =>
+  typeof value === "string" && value.trim() ? value.trim() : "";
+
+const readSharedTableMeta = async (
+  thunkApi: any,
+  tableDbKey: string
+): Promise<Record<string, unknown> | null> => {
+  if (typeof thunkApi?.dispatch !== "function") return null;
+  const result = await thunkApi.dispatch(readAndWait(tableDbKey));
+  if (!readAndWait.fulfilled.match(result) || !result.payload || typeof result.payload !== "object") {
+    return null;
+  }
+  return result.payload as Record<string, unknown>;
+};
+
+export async function shareTableFunc(
+  args: ShareTableArgs,
+  thunkApi: any
+): Promise<ShareTableResult> {
+  const state = thunkApi?.getState?.();
+  const dialogId = state ? selectCurrentDialogId(state) : undefined;
+  const latestUserInput = state
+    ? selectAllMsgs(state, dialogId)
+        .slice()
+        .reverse()
+        .find((message) => message?.role === "user" && typeof message?.content === "string")
+        ?.content
+    : undefined;
+  if (!hasExplicitPublicShareRequest(latestUserInput)) {
+    throw new Error("当前策略不允许在用户未明确要求公开/社区分享时自动发布表。");
+  }
+
+  const tableDbKey = resolveTableDbKey(args);
+  const tableMeta =
+    !asNonEmptyString(args.tenantId) || !asNonEmptyString(args.tableId) || !asNonEmptyString(args.title)
+      ? await readSharedTableMeta(thunkApi, tableDbKey)
+      : null;
+  const tenantId = asNonEmptyString(args.tenantId) || asNonEmptyString(tableMeta?.tenantId);
+  const tableId = asNonEmptyString(args.tableId) || asNonEmptyString(tableMeta?.tableId);
+  const title =
+    asNonEmptyString(args.title) ||
+    asNonEmptyString(tableMeta?.displayName) ||
+    asNonEmptyString(tableMeta?.title) ||
+    tableId ||
+    tableDbKey;
+
+  const result = await shareResourceAction(
+    {
+      type: DataType.TABLE,
+      data: {
+        dbKey: tableDbKey,
+        ...(tenantId ? { tenantId } : {}),
+        ...(tableId ? { tableId } : {}),
+        displayName: title,
+      },
+      title,
+      description:
+        typeof args.description === "string" && args.description.trim()
+          ? args.description.trim()
+          : undefined,
+      visibility: args.visibility ?? "community",
+    },
+    thunkApi
+  );
+
+  return {
+    rawData: {
+      ...result,
+      url: `/share/${result.token}`,
+    },
+    displayData: `表已分享：/share/${result.token}`,
+  };
+}

package/ai/tools/table/toolShared.ts

@@ -0,0 +1,129 @@
+import type { RootState } from "../../../app/store";
+import { readAndWait, patch, write } from "../../../database/dbSlice";
+import { metaKey, rowKey } from "../../../database/keys";
+import { DataType } from "../../../create/types";
+import { loadTableRows } from "../../../render/table/tableSlice";
+import type { TableMeta } from "../../../render/table/types";
+
+export const resolveTableIdentity = (
+  args: { tenantId?: string; tableId?: string },
+  state: RootState
+) => {
+  const currentTable = state.table.currentTable;
+  const tenantId = args.tenantId ?? currentTable?.tenantId;
+  const tableId = args.tableId ?? currentTable?.tableId;
+  return { tenantId, tableId, currentTable };
+};
+
+export async function loadTableMetaOrThrow(
+  thunkApi: any,
+  tenantId: string,
+  tableId: string
+): Promise<TableMeta> {
+  const result = await thunkApi.dispatch(readAndWait(metaKey(tenantId, tableId)));
+  if (!readAndWait.fulfilled.match(result) || !result.payload) {
+    const message =
+      (result.payload as any)?.message ||
+      result.error?.message ||
+      `找不到表 ${tableId} 的定义。`;
+    throw new Error(message);
+  }
+  return result.payload as TableMeta;
+}
+
+export async function ensureRowsLoaded(
+  thunkApi: any,
+  tenantId: string,
+  tableId: string
+): Promise<any[]> {
+  const result = await thunkApi.dispatch(loadTableRows({ tenantId, tableId }));
+  if (!loadTableRows.fulfilled.match(result)) {
+    const message =
+      (result.payload as any) ||
+      result.error?.message ||
+      "加载表行失败";
+    throw new Error(message);
+  }
+
+  const state = thunkApi.getState() as RootState;
+  return state.table.rows.filter(
+    (row: any) => row?.tenantId === tenantId && row?.tableId === tableId && !row?.deletedAt
+  );
+}
+
+export async function resolveRowOrThrow(
+  thunkApi: any,
+  args: { tenantId: string; tableId: string; rowId?: string; dbKey?: string }
+) {
+  const { tenantId, tableId, rowId, dbKey } = args;
+
+  if (!rowId && !dbKey) {
+    throw new Error("需要提供 rowId 或 dbKey 才能定位表行。");
+  }
+
+  const finalDbKey = dbKey || rowKey.single(tenantId, tableId, String(rowId));
+  const readResult = await thunkApi.dispatch(readAndWait(finalDbKey));
+  if (readAndWait.fulfilled.match(readResult) && readResult.payload && !readResult.payload.deletedAt) {
+    return readResult.payload;
+  }
+
+  const rows = await ensureRowsLoaded(thunkApi, tenantId, tableId);
+  const found = rows.find((row) => row?.dbKey === finalDbKey || row?.rowId === rowId);
+  if (!found) {
+    throw new Error(`找不到要操作的行：${rowId || finalDbKey}`);
+  }
+  return found;
+}
+
+export async function writeRow(thunkApi: any, row: any) {
+  const result = await thunkApi.dispatch(
+    write({
+      data: row,
+      customKey: row.dbKey,
+    })
+  );
+  if (!write.fulfilled.match(result)) {
+    const message =
+      (result.payload as any)?.message ||
+      result.error?.message ||
+      "写入表行失败";
+    throw new Error(message);
+  }
+  return result.payload;
+}
+
+export async function patchRecord(thunkApi: any, dbKey: string, changes: Record<string, any>) {
+  const result = await thunkApi.dispatch(
+    patch({
+      dbKey,
+      changes,
+    })
+  );
+  if (!patch.fulfilled.match(result)) {
+    const message =
+      (result.payload as any)?.message ||
+      result.error?.message ||
+      `更新记录失败：${dbKey}`;
+    throw new Error(message);
+  }
+  return result.payload;
+}
+
+export function buildNewRow(
+  tenantId: string,
+  tableId: string,
+  values: Record<string, any>
+) {
+  const { dbKey, rowId } = rowKey.create(tenantId, tableId);
+  const now = new Date().toISOString();
+  return {
+    dbKey,
+    tenantId,
+    tableId,
+    rowId,
+    createdAt: now,
+    updatedAt: now,
+    type: DataType.TABLE_ROW as const,
+    ...values,
+  };
+}

package/ai/tools/taobaoTmallProductScraperTool.ts

@@ -0,0 +1,49 @@
+import { callApifyActor } from "./apifyActorClient";
+
+export const taobaoTmallProductScraperFunctionSchema = {
+  name: "taobaoTmallProductScraper",
+  description:
+    "使用 Apify Taobao/Tmall Product Scraper 获取淘宝/天猫商品真实详情，返回标题、价格、SKU、库存、图片、店铺、属性和规格参数。适合用户提供淘宝/天猫链接或商品 ID 后做真实参数对比。",
+  parameters: {
+    type: "object",
+    properties: {
+      itemId: {
+        type: "string",
+        description:
+          "淘宝/天猫数字商品 ID。可从链接中的 id 参数提取，例如 https://item.taobao.com/item.htm?id=744983869996。",
+      },
+      detailDepth: {
+        type: "string",
+        enum: ["lite", "standard", "full"],
+        description:
+          "详情深度。full 会尽量返回优惠后价格、属性、规格、SKU 和促销信息；默认 full。",
+        default: "full",
+      },
+    },
+    required: ["itemId"],
+  },
+};
+
+export async function taobaoTmallProductScraperFunc(
+  args: {
+    itemId: string;
+    detailDepth?: "lite" | "standard" | "full";
+  },
+  thunkApi: any
+) {
+  const itemId = String(args.itemId ?? "").trim();
+  if (!/^\d{6,}$/.test(itemId)) {
+    throw new Error("淘宝/天猫商品详情抓取失败：itemId 必须是有效的数字商品 ID。");
+  }
+
+  return callApifyActor(thunkApi, {
+    actorId: "sian.agency~taobao-tmall-product-scraper",
+    input: {
+      operation: "productDetail",
+      itemId,
+      detailDepth: args.detailDepth ?? "full",
+    },
+    resultType: "datasetItems",
+    displayName: "Taobao/Tmall Product Scraper",
+  });
+}

package/ai/tools/toolApiClient.ts

@@ -0,0 +1,279 @@
+/**
+ * toolApiClient.ts
+ *
+ * 所有 AI tool 调用后端 API 的统一工具模块。
+ *
+ * 解决的问题：
+ * - 相对路径（如 "/api/xxx"）在 React Native 中无法解析。
+ * - 多个 tool 文件中重复定义相同的 getRequestConfig / buildRequestHeaders 等辅助函数。
+ *
+ * 使用方式：
+ *   const data = await callToolApi(thunkApi, "/api/exa-search", body);
+ *   const data = await callToolApi(thunkApi, "/api/apify-actor", body, { withAuth: true });
+ */
+
+import { extractCustomId } from "../../core/prefix";
+
+// ─────────────────────────────────────────────
+// 基础提取：从 Redux state 中获取服务器配置
+// ─────────────────────────────────────────────
+
+export interface RequestConfig {
+    currentServer: string;
+    token: string | null;
+}
+
+export interface ToolRequestContext extends RequestConfig {
+    baseUrl: string;
+}
+
+const MAIN_SERVER = "https://nolo.chat";
+
+const getIsDesktopApp = (): boolean =>
+    typeof window !== "undefined" && Boolean((window as any).__NOLO_DESKTOP__);
+
+const isLocalServerUrl = (value?: string | null): boolean => {
+    if (!value) return false;
+    try {
+        const hostname = new URL(value).hostname.toLowerCase();
+        return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+    } catch {
+        return false;
+    }
+};
+
+const resolveDesktopSafeServer = (value?: string | null): string => {
+    if (!getIsDesktopApp()) return value || MAIN_SERVER;
+    return isLocalServerUrl(value) ? MAIN_SERVER : value || MAIN_SERVER;
+};
+
+const selectCurrentServerFromState = (state: any): string =>
+    resolveDesktopSafeServer(state?.settings?.currentServer);
+
+const selectCurrentTokenFromState = (state: any): string | null =>
+    typeof state?.auth?.currentToken === "string" ? state.auth.currentToken : null;
+
+const selectCurrentDialogKeyFromState = (state: any): string | null =>
+    typeof state?.dialog?.currentDialogKey === "string" ? state.dialog.currentDialogKey : null;
+
+export const resolveToolBaseUrl = (currentServer?: string | null): string => {
+    const _window = (globalThis as any).window;
+    if (!_window) return (currentServer || "").replace(/\/+$/, "");
+    const fallbackLocal = _window.location.origin;
+    if (!currentServer) return fallbackLocal;
+    return currentServer.replace(/\/+$/, "");
+};
+
+const DESKTOP_LOCAL_TOOL_PATHS = new Set([
+    "/api/exec-shell",
+    "/api/check-env",
+    "/api/read-file",
+    "/api/write-file",
+    "/api/apply-edit",
+    "/api/apply-line-edits",
+    "/api/code-search",
+    "/api/search-repo",
+    "/api/desktop/files/roots",
+    "/api/desktop/files/roots/request",
+    "/api/desktop/files/list",
+    "/api/desktop/files/read",
+    "/api/desktop/files/plan",
+    "/api/desktop/files/approve",
+    "/api/desktop/files/execute",
+    "/api/desktop/files/undo",
+    "/api/desktop/files/history",
+]);
+
+const getWindowOrigin = (): string | null => {
+    const _window = (globalThis as any).window;
+    const origin = _window?.location?.origin;
+    return typeof origin === "string" && origin ? origin.replace(/\/+$/, "") : null;
+};
+
+export const resolveToolApiBaseUrl = (
+    currentServer?: string | null,
+    path?: string
+): string => {
+    if (path && DESKTOP_LOCAL_TOOL_PATHS.has(path) && getIsDesktopApp()) {
+        const localOrigin = getWindowOrigin();
+        if (localOrigin) return localOrigin;
+    }
+    return resolveToolBaseUrl(currentServer);
+};
+
+export const getRequestConfig = (thunkApi: any): RequestConfig => {
+    const state = thunkApi.getState();
+    const currentServer = selectCurrentServerFromState(state);
+    const token = selectCurrentTokenFromState(state);
+    if (!currentServer) throw new Error("无法获取当前服务器地址。");
+    return { currentServer, token };
+};
+
+export const getToolBaseUrl = (thunkApi: any): string => {
+    const { currentServer } = getRequestConfig(thunkApi);
+    const baseUrl = resolveToolBaseUrl(currentServer);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    return baseUrl;
+};
+
+export const getToolRequestContext = (thunkApi: any): ToolRequestContext => {
+    const { currentServer, token } = getRequestConfig(thunkApi);
+    const baseUrl = resolveToolBaseUrl(currentServer);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    return {
+        currentServer,
+        token,
+        baseUrl,
+    };
+};
+
+// ─────────────────────────────────────────────
+// 统一 POST 请求入口
+// ─────────────────────────────────────────────
+
+export interface CallToolApiOptions {
+    /** 是否在请求头中附带 Authorization token，默认 false */
+    withAuth?: boolean;
+    /** 生产受控 devtool 路由需要知道是哪一个 agent 在调用。 */
+    agentKey?: string | null;
+}
+
+const maybeAttachDialogId = (thunkApi: any, body: object): object => {
+    if (!body || typeof body !== "object" || Array.isArray(body)) return body;
+    if ("dialogId" in body) return body;
+
+    const state = thunkApi.getState();
+    const currentDialogKey = selectCurrentDialogKeyFromState(state);
+    const dialogId = currentDialogKey ? extractCustomId(currentDialogKey) : null;
+    if (!dialogId) return body;
+
+    return {
+        ...body,
+        dialogId,
+    };
+};
+
+export class ToolApiError extends Error {
+    status?: number;
+    code?: string;
+    details?: unknown;
+
+    constructor(message: string, options?: { status?: number; code?: string; details?: unknown }) {
+        super(message);
+        this.name = "ToolApiError";
+        this.status = options?.status;
+        this.code = options?.code;
+        this.details = options?.details;
+    }
+}
+
+export const buildToolRequestHeaders = (
+    thunkApi: any,
+    options: CallToolApiOptions = {}
+): Record<string, string> => {
+    const { withAuth = false, agentKey } = options;
+    const { token } = getRequestConfig(thunkApi);
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (withAuth && token) {
+        headers["Authorization"] = `Bearer ${token}`;
+    }
+    if (agentKey && typeof agentKey === "string" && agentKey.trim()) {
+        headers["X-Nolo-Agent-Key"] = agentKey.trim();
+    }
+    if (typeof window !== "undefined" && (window as any).__NOLO_DESKTOP__) {
+        headers["X-Nolo-Desktop-Tool"] = "1";
+    }
+    return headers;
+};
+
+const buildResponsePreview = (text: string): string =>
+    text
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 240);
+
+const looksLikeHtmlResponse = (text: string, contentType: string | null): boolean => {
+    if (contentType?.toLowerCase().includes("text/html")) return true;
+    const trimmed = text.trim().toLowerCase();
+    return trimmed.startsWith("<!doctype html") || trimmed.startsWith("<html");
+};
+
+/**
+ * 向本项目后端发起 POST 请求的统一封装。
+ * - 自动从 Redux state 中读取 currentServer，构建完整 URL（兼容 Web & RN）。
+ * - 自动处理错误响应，抛出包含状态码和错误信息的 Error。
+ *
+ * @param thunkApi  Redux Thunk API
+ * @param path      API 路径，如 "/api/exa-search"
+ * @param body      请求体对象
+ * @param options   选项：{ withAuth } 是否附带 token
+ * @returns         解析后的 JSON 数据
+ */
+export async function callToolApi<T = any>(
+    thunkApi: any,
+    path: string,
+    body: object,
+    options: CallToolApiOptions = {}
+): Promise<T> {
+    const { currentServer } = getRequestConfig(thunkApi);
+
+    const baseUrl = resolveToolApiBaseUrl(currentServer, path);
+    if (!baseUrl) throw new Error("无法获取工具服务器地址。");
+    const url = `${baseUrl}${path}`;
+    const headers = buildToolRequestHeaders(thunkApi, options);
+
+    const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(maybeAttachDialogId(thunkApi, body)),
+    });
+
+    const contentType = response.headers.get("content-type");
+    const responseText = await response.text();
+
+    if (!response.ok) {
+        let errorMessage = `API 请求失败，状态码: ${response.status}`;
+        let errorCode: string | undefined;
+        let errorDetails: unknown;
+        try {
+            const errorData = JSON.parse(responseText) as Record<string, any>;
+            const err = errorData?.error;
+            if (err) {
+                errorMessage += `: ${err.message ?? JSON.stringify(err)}`;
+                errorCode = typeof err.code === "string" ? err.code : undefined;
+                errorDetails = err.details;
+            }
+        } catch {
+            errorCode = looksLikeHtmlResponse(responseText, contentType)
+                ? "HTML_ERROR_RESPONSE"
+                : "NON_JSON_ERROR_RESPONSE";
+            errorDetails = {
+                contentType,
+                responsePreview: buildResponsePreview(responseText),
+            };
+            if (typeof (errorDetails as any).responsePreview === "string" && (errorDetails as any).responsePreview) {
+                errorMessage += `: ${(errorDetails as any).responsePreview}`;
+            }
+        }
+        throw new ToolApiError(errorMessage, {
+            status: response.status,
+            code: errorCode,
+            details: errorDetails,
+        });
+    }
+
+    try {
+        return JSON.parse(responseText) as T;
+    } catch {
+        throw new ToolApiError("服务端返回了无法解析的非 JSON 响应", {
+            status: response.status,
+            code: looksLikeHtmlResponse(responseText, contentType)
+                ? "HTML_RESPONSE"
+                : "INVALID_JSON_RESPONSE",
+            details: {
+                contentType,
+                responsePreview: buildResponsePreview(responseText),
+            },
+        });
+    }
+}

package/ai/tools/toolPacks.ts

@@ -0,0 +1,19 @@
+/**
+ * 能力分级定义 (Capability Tiers)
+ */
+export const TOOL_PACKS = {
+  // L1 - 核心：交互 + 记忆读写 + 自我更新，所有 Agent 必有
+  CORE: ["ui_ask_choice", "rememberMemory", "read", "searchDialogMessages", "createDoc", "updateDoc", "search_workspace", "search_all_spaces", "updateSelf", "queryModelUsage", "createDialogGoal", "getDialogGoal", "completeDialogGoal", "createScheduledTask", "notifyUser"],
+  // L2 - 联网搜索：配置了 web-capable tools 的 Agent 默认加，纯 QA bot 不加
+  LIGHT_WEB: ["exa_search", "read_x_post", "read_xhs_profile"],
+  // L3 - 深度浏览器：全套复杂网页交互
+  FULL_BROWSER: [
+    "browser_openSession",
+    "browser_closeSession",
+    "browser_click",
+    "browser_typeText",
+    "browser_readContent",
+    "browser_selectOption",
+    "fetchWebpage",
+  ],
+} as const;

package/ai/tools/toolResultError.ts

@@ -0,0 +1,42 @@
+export class ToolResultError extends Error {
+  code?: string;
+  rawData?: unknown;
+  displayData?: string;
+  retryable?: boolean;
+
+  constructor(
+    message: string,
+    options?: {
+      code?: string;
+      rawData?: unknown;
+      displayData?: string;
+      retryable?: boolean;
+    }
+  ) {
+    super(message);
+    this.name = "ToolResultError";
+    this.code = options?.code;
+    this.rawData = options?.rawData;
+    this.displayData = options?.displayData;
+    this.retryable = options?.retryable;
+  }
+}
+
+export const getToolResultErrorData = (error: unknown) => {
+  if (!error || typeof error !== "object") return null;
+  const candidate = error as {
+    rawData?: unknown;
+    displayData?: string;
+    code?: string;
+    retryable?: boolean;
+    message?: string;
+  };
+  return {
+    rawData: candidate.rawData,
+    displayData: candidate.displayData,
+    code: candidate.code,
+    retryable: candidate.retryable,
+    message: candidate.message,
+  };
+};
+