nolo-cli 0.1.13 → 0.1.15

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/toolApiClient.ts

@@ -0,0 +1,198 @@
+/**
+ * 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 type { RootState } from "app/store";
+import { selectCurrentServer } from "app/settings/settingSlice";
+import { selectCurrentToken } from "auth/authSlice";
+import { selectCurrentDialogKey } from "chat/dialog/dialogSlice";
+import { extractCustomId } from "core/prefix";
+
+// ─────────────────────────────────────────────
+// 基础提取：从 Redux state 中获取服务器配置
+// ─────────────────────────────────────────────
+
+export interface RequestConfig {
+    currentServer: string;
+    token: string | null;
+}
+
+export interface ToolRequestContext extends RequestConfig {
+    baseUrl: string;
+}
+
+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(/\/+$/, "");
+};
+
+export const getRequestConfig = (thunkApi: any): RequestConfig => {
+    const state = thunkApi.getState() as RootState;
+    const currentServer = selectCurrentServer(state);
+    const token = selectCurrentToken(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;
+}
+
+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() as RootState;
+    const currentDialogKey = selectCurrentDialogKey(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;
+    }
+}
+
+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 { withAuth = false } = options;
+    const { currentServer, token } = getRequestConfig(thunkApi);
+
+    const url = `${currentServer}${path}`;
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (withAuth && token) {
+        headers["Authorization"] = `Bearer ${token}`;
+    }
+
+    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/toolNameAliases.ts

@@ -0,0 +1,57 @@
+const LEGACY_TOOL_NAME_ALIASES: Record<string, string> = {
+  createPage: "createDoc",
+  updatePage: "updateDoc",
+  update_page: "updateDoc",
+  create_page: "createDoc",
+  fetchwebpage: "fetchWebpage",
+  fetch_webpage: "fetchWebpage",
+  "fetch-page": "fetchWebpage",
+  exasearch: "exa_search",
+  "exa-search": "exa_search",
+  exa_search: "exa_search",
+  readDoc: "readDoc",
+  readpage: "readDoc",
+  read_page: "readDoc",
+  read_doc: "readDoc",
+  createdoc: "createDoc",
+  updateDocTool: "updateDoc",
+};
+
+const normalizeToolName = (name: string): string =>
+  name.replace(/[-_]/g, "").toLowerCase();
+
+export const canonicalizeToolName = (rawName: string): string => {
+  const trimmedName = rawName.trim();
+  if (!trimmedName) return rawName;
+
+  if (LEGACY_TOOL_NAME_ALIASES[trimmedName]) {
+    return LEGACY_TOOL_NAME_ALIASES[trimmedName];
+  }
+
+  const normalizedRawName = normalizeToolName(trimmedName);
+  const matchedAlias = Object.entries(LEGACY_TOOL_NAME_ALIASES).find(
+    ([alias]) => normalizeToolName(alias) === normalizedRawName,
+  );
+
+  return matchedAlias?.[1] ?? trimmedName;
+};
+
+export const canonicalizeToolNames = (toolNames: string[]): string[] =>
+  Array.from(
+    new Set(
+      toolNames
+        .filter((toolName): toolName is string => typeof toolName === "string")
+        .map(canonicalizeToolName),
+    ),
+  );
+
+export const prioritizeToolNames = (
+  toolNames: string[],
+  preferredToolNames: string[],
+): string[] => {
+  const canonicalTools = canonicalizeToolNames(toolNames);
+  const preferred = new Set(canonicalizeToolNames(preferredToolNames));
+  const prioritized = canonicalTools.filter((toolName) => preferred.has(toolName));
+  const remaining = canonicalTools.filter((toolName) => !preferred.has(toolName));
+  return [...prioritized, ...remaining];
+};

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,
+  };
+};
+