nolo-cli 0.1.26 → 0.1.30

package/server/tasks.ts

@@ -0,0 +1,113 @@
+import { DataType } from "../create/types";
+import { parseWeatherParams, fetchWeatherData } from "../integrations/weather";
+import { ulid } from "ulid";
+
+// 任务 1 - 查询收藏的人最多前十的浪点
+// const TOP_COLLECTORS_QUERY_INTERVAL = "0 0 * * *"; // 每天凌晨 0 点执行一次
+const TOP_COLLECTORS_QUERY_INTERVAL = "* * * * * *";
+
+const queryTopTenCollectors = async () => {
+  const result = [];
+  const collectors = result.map((item) => {
+    return { lat: item.lat, lng: item.lng };
+  });
+  return collectors;
+};
+
+// 单独的处理天气数据的函数
+const processWeatherData = async (weatherData, collector) => {
+  weatherData.hours.forEach(async (hour) => {
+    const specificTime = new Date(hour.time).getTime();
+    const ulidForSpecificTime = ulid(specificTime);
+    const customKey = ulidForSpecificTime;
+    const id = customKey;
+    // 在这里添加 lat 和 lng 到 hour 数据中
+    const augmentedHour = {
+      ...hour,
+      lat: collector.lat, // 获取当前 collector 的 lat
+      lng: collector.lng, // 获取当前 collector 的 lng
+      created_at: Date.now(),
+      type: DataType.SurfInfo,
+    };
+    const tableName = "surf_info";
+    // await serverCreateTable(nolotusId, "surf_info");
+    // await serverWriteDataInTable(nolotusId, tableName, hour.time, augmentedHour);
+  });
+};
+
+const sendRequestsToTopTenCollectors = async (
+  collectors,
+  shouldFetchAll = false
+) => {
+  let promises = [];
+
+  if (shouldFetchAll || collectors.length === 0) {
+    // 请求全部数据或者处理空收集器数组的情况
+    promises = collectors.map((collector) => {
+      const weatherParams = parseWeatherParams({
+        lat: collector.lat,
+        lng: collector.lng,
+      });
+      return fetchWeatherData(weatherParams).then((weatherData) => ({
+        weatherData,
+        collector,
+      }));
+    });
+  } else {
+    // 仅请求第一个
+    const collector = collectors[0];
+    const weatherParams = parseWeatherParams({
+      lat: collector.lat,
+      lng: collector.lng,
+    });
+    promises = [
+      fetchWeatherData(weatherParams).then((weatherData) => ({
+        weatherData,
+        collector,
+      })),
+    ];
+  }
+
+  const results = await Promise.allSettled(promises);
+
+  // 统一处理天气数据，无论是请求单个还是全部
+  const processedResults = results.map((result) => {
+    if (result.status === "fulfilled") {
+      try {
+        const { weatherData, collector } = result.value;
+        processWeatherData(weatherData, collector); // 处理天气数据
+        return { success: true, data: weatherData }; // 可以选择返回处理后的数据或不返回
+      } catch (error) {
+        return { success: false, error: error.toString() };
+      }
+    } else {
+      return { success: false, error: result.reason };
+    }
+  });
+
+  return processedResults;
+};
+
+export const runTopCollectorsTask = async () => {
+  const collectors = await queryTopTenCollectors();
+  sendRequestsToTopTenCollectors(collectors);
+};
+// 任务 2 - 其他任务
+const OTHER_TASK_INTERVAL = "*/30 * * * * *"; // 每隔 5 分钟执行一次
+const runOtherTask = async () => {
+  // 这里是伪代码，实际需要根据您的需求进行修改
+};
+
+export const tasks = [
+  {
+    name: "top collectors",
+    interval: TOP_COLLECTORS_QUERY_INTERVAL,
+    task: runTopCollectorsTask,
+  },
+  // {
+  //   name: "other task",
+  //   interval: OTHER_TASK_INTERVAL,
+  //   task: runOtherTask,
+  // },
+];
+// runTopCollectorsTask();

package/server/waffoPaymentRoutes.ts

@@ -0,0 +1,5 @@
+import { createPaymentProviderRoutes } from "./payments/paymentRoutes";
+import { waffoPaymentProvider } from "./payments/waffo/waffoPaymentProvider";
+
+export const waffoPaymentRoutes: Record<string, any> =
+  createPaymentProviderRoutes(waffoPaymentProvider);

package/server/webUtilityRoutes.ts

@@ -0,0 +1,50 @@
+import { handleFetchWebpage } from "./handlers/fetchWebpageHandler";
+import { handleReadXPost } from "./handlers/readXPostHandler";
+import { handleApifyActor } from "./handlers/apifyActorHandler";
+import { handleExaSearch } from "./handlers/exaSearchHandler";
+import { createApiRouteFamily } from "./apiRouteAdapter";
+
+let browserToolHandlerPromise: Promise<
+  typeof import("./handlers/browserToolHandler")
+> | null = null;
+
+const loadBrowserToolHandler = async () => {
+  if (!browserToolHandlerPromise) {
+    browserToolHandlerPromise = import("./handlers/browserToolHandler").catch(
+      (error) => {
+        browserToolHandlerPromise = null;
+        throw error;
+      }
+    );
+  }
+
+  return browserToolHandlerPromise;
+};
+
+const handleBrowserToolLazy = async (req: Request) => {
+  const { handleBrowserTool } = await loadBrowserToolHandler();
+  return handleBrowserTool(req);
+};
+
+export const webUtilityRoutes: Record<string, any> = createApiRouteFamily([
+  {
+    path: "/api/fetch-webpage",
+    handlers: { POST: handleFetchWebpage },
+  },
+  {
+    path: "/api/read-x-post",
+    handlers: { POST: handleReadXPost },
+  },
+  {
+    path: "/api/apify-actor",
+    handlers: { POST: handleApifyActor },
+  },
+  {
+    path: "/api/browser-tool",
+    handlers: { POST: handleBrowserToolLazy },
+  },
+  {
+    path: "/api/exa-search",
+    handlers: { POST: handleExaSearch },
+  },
+]);

package/server/workerValidator.ts

@@ -0,0 +1,224 @@
+/**
+ * Worker 代码合法性校验
+ *
+ * 两层防护：
+ * 1. 静态扫描（正则）：快速拒绝明显的禁用 API，无需解析 AST
+ * 2. Bun.build 语法检查：捕获语法错误，确保代码可编译
+ *
+ * 设计原则：
+ * - 误报宁多勿少（安全优先）
+ * - 错误信息要具体，方便用户修正
+ * - 校验在 deploy 前执行，不依赖 CF API
+ */
+
+export interface ValidationResult {
+  ok: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+// ── 静态规则 ──────────────────────────────────────────────────
+
+/**
+ * 禁用的 API 模式。
+ * 每条规则包含：pattern（正则）、reason（用户可读原因）、severity
+ */
+const FORBIDDEN_PATTERNS: Array<{
+  pattern: RegExp;
+  reason: string;
+  severity: "error" | "warning";
+}> = [
+  // Node.js/Bun 专用模块
+  {
+    pattern: /\brequire\s*\(/,
+    reason: "禁止使用 require()，Worker 运行时只支持 ES Module import",
+    severity: "error",
+  },
+  {
+    pattern: /\bimport\s+.*\bfs\b/,
+    reason: "禁止导入 'fs' 模块，Worker 运行时无文件系统",
+    severity: "error",
+  },
+  {
+    pattern: /\bimport\s+.*\bpath\b/,
+    reason: "禁止导入 'path' 模块，Worker 运行时无文件系统",
+    severity: "error",
+  },
+  {
+    pattern: /\bimport\s+.*\bchild_process\b/,
+    reason: "禁止导入 'child_process'，Worker 运行时无进程管理",
+    severity: "error",
+  },
+  {
+    pattern: /\bimport\s+.*\bnet\b|\bimport\s+.*\bhttp\b|\bimport\s+.*\bhttps\b/,
+    reason: "禁止导入 Node.js net/http/https，请使用 Web 标准 fetch API",
+    severity: "error",
+  },
+  // 顶层 CDN URL import（在 Bun Worker 沙箱里无法解析网络路径）
+  {
+    pattern: /^\s*import\s+.*from\s+['"]https?:\/\//m,
+    reason: "禁止在 Worker 顶层 import CDN 包（import ... from 'https://...'）。需要前端框架时，请在返回的 HTML 里用 importmap + <script type=\"module\"> 方式，在浏览器端加载",
+    severity: "error",
+  },
+  // Bun 专用 API
+  {
+    pattern: /\bBun\s*\./,
+    reason: "禁止使用 Bun.* API（在 CF Workers 上不可用）",
+    severity: "error",
+  },
+  // process 对象（部分安全，但危险方法禁止）
+  {
+    pattern: /\bprocess\s*\.\s*exit\b/,
+    reason: "禁止使用 process.exit()，Worker 不应主动退出",
+    severity: "error",
+  },
+  {
+    pattern: /\bprocess\s*\.\s*env\b/,
+    reason: "禁止使用 process.env，请使用 env 参数（fetch(request, env)）",
+    severity: "error",
+  },
+  // 危险 eval 类
+  {
+    pattern: /\beval\s*\(/,
+    reason: "禁止使用 eval()（安全风险）",
+    severity: "error",
+  },
+  {
+    pattern: /new\s+Function\s*\(/,
+    reason: "禁止使用 new Function()（安全风险）",
+    severity: "error",
+  },
+  // 必须有 export default
+  // （在 REQUIRED_PATTERNS 里检查，此处不放）
+
+  // 警告类（允许但提示）
+  {
+    pattern: /console\.(log|error|warn|info)/,
+    reason: "console.log 在 CF Workers 中会产生日志费用，建议移除",
+    severity: "warning",
+  },
+];
+
+/** 必须存在的模式 */
+const REQUIRED_PATTERNS: Array<{ pattern: RegExp; reason: string }> = [
+  {
+    pattern: /export\s+default\s*\{[\s\S]*fetch/,
+    reason:
+      '代码必须包含 export default { async fetch(request, env) {...} }。' +
+      '示例：\nexport default {\n  async fetch(request, env) {\n    return new Response("Hello!");\n  }\n};',
+  },
+];
+
+// ── 语法检查（Bun.build 试编译）─────────────────────────────
+
+import { join } from "path";
+import { tmpdir } from "os";
+import { writeFile, unlink } from "fs/promises";
+
+async function checkSyntax(code: string): Promise<string | null> {
+  const tmpFile = join(tmpdir(), `nolo-validate-${Date.now()}.mjs`);
+  try {
+    await writeFile(tmpFile, code, "utf-8");
+    const result = await Bun.build({
+      entrypoints: [tmpFile],
+      target: "browser",
+      format: "esm",
+    });
+    if (!result.success) {
+      const msgs = result.logs
+        .filter((l) => l.level === "error")
+        .map((l) => l.message)
+        .join("; ");
+      return msgs || "代码语法错误（无法编译）";
+    }
+    return null;
+  } catch (err: any) {
+    return `语法检查失败: ${err.message}`;
+  } finally {
+    unlink(tmpFile).catch(() => {});
+  }
+}
+
+// ── 主校验函数 ────────────────────────────────────────────────
+
+/**
+ * 校验单文件 Worker 代码。
+ *
+ * @param code  用户提交的代码字符串
+ * @returns     { ok, errors, warnings }
+ *              ok=false 时不应继续部署
+ */
+export async function validateWorkerCode(code: string): Promise<ValidationResult> {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (!code || typeof code !== "string") {
+    return { ok: false, errors: ["代码不能为空"], warnings: [] };
+  }
+
+  // 1. 必须包含 export default { fetch }
+  for (const { pattern, reason } of REQUIRED_PATTERNS) {
+    if (!pattern.test(code)) {
+      errors.push(reason);
+    }
+  }
+
+  // 2. 禁用 API 扫描
+  for (const { pattern, reason, severity } of FORBIDDEN_PATTERNS) {
+    if (pattern.test(code)) {
+      if (severity === "error") errors.push(reason);
+      else warnings.push(reason);
+    }
+  }
+
+  // 3. 语法检查（只有通过前面检查才做，避免无意义的编译错误）
+  if (errors.length === 0) {
+    const syntaxError = await checkSyntax(code);
+    if (syntaxError) {
+      errors.push(`语法错误: ${syntaxError}`);
+    }
+  }
+
+  return { ok: errors.length === 0, errors, warnings };
+}
+
+/**
+ * 多文件项目的校验：只检查入口文件（bundle 后再做语法检查）。
+ * 入口文件识别逻辑与 appBundler.ts 一致。
+ */
+export function validateWorkerFiles(
+  files: Array<{ name: string; code: string }>
+): ValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (!files.length) {
+    return { ok: false, errors: ["files 数组不能为空"], warnings: [] };
+  }
+
+  // 每个文件不能为空
+  for (const f of files) {
+    if (!f.name || !f.code) {
+      errors.push(`文件 "${f.name || "(未命名)"}" 的 name 和 code 不能为空`);
+    }
+  }
+
+  const ENTRY_NAMES = ["index.ts", "index.js", "main.ts", "main.js", "worker.ts", "worker.js"];
+  const entry = files.find((f) => ENTRY_NAMES.includes(f.name.toLowerCase()));
+  if (!entry) {
+    warnings.push(
+      `未找到标准入口文件（${ENTRY_NAMES.join(" / ")}），将使用第一个文件 "${files[0].name}" 作为入口`
+    );
+  }
+
+  // 入口文件禁用 API 扫描
+  const entryFile = entry ?? files[0];
+  for (const { pattern, reason, severity } of FORBIDDEN_PATTERNS) {
+    if (pattern.test(entryFile.code)) {
+      if (severity === "error") errors.push(reason);
+      else warnings.push(reason);
+    }
+  }
+
+  return { ok: errors.length === 0, errors, warnings };
+}

package/share/action.ts

@@ -0,0 +1,225 @@
+import type { AppThunkApi } from "../app/store";
+import { selectCurrentUser, selectUserId } from "../auth/authSlice";
+import {
+  selectCurrentServer,
+  selectRemoteServers,
+} from "../app/settings/settingSlice";
+import { normalizeTimeFields } from "../database/actions/common";
+import { createUserKey } from "../database/keys";
+import { noloDeleteRequest, noloWriteRequest } from "../database/requests";
+
+import type { SharedObject, ShareType } from "./types";
+import { shareKey } from "./keys";
+import {
+  toNonEmptyString,
+  sanitizeShareData,
+  extractCoverImage,
+  extractAgentInfo,
+  resolveShareAuthorIdentity,
+} from "./helpers";
+
+const generateToken = (): string => {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  const charsLen = chars.length; // 36
+  const maxValid = 252; // 252 = 36 * 7, largest multiple of 36 ≤ 255
+  let token = "";
+  while (token.length < 10) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    for (let i = 0; i < bytes.length && token.length < 10; i++) {
+      if (bytes[i] < maxValid) {
+        token += chars.charAt(bytes[i] % charsLen);
+      }
+    }
+  }
+  return token;
+};
+
+export interface ShareActionConfig {
+  type: ShareType;
+  data: Record<string, unknown>;
+  title: string;
+  description?: string;
+  visibility?: "private" | "community";
+}
+
+const assertDialogShareMessagesPresent = (
+  type: ShareType,
+  data: Record<string, unknown>
+) => {
+  if (type !== "dialog") return;
+  const messages = Array.isArray(data.messages)
+    ? data.messages
+    : Array.isArray(data.history)
+      ? data.history
+      : [];
+  if (messages.length > 0) return;
+  throw new Error("Cannot share dialog without persisted messages.");
+};
+
+const resolveTableSharePayload = (
+  type: ShareType,
+  data: Record<string, unknown>,
+  userId: string,
+  originServer: string
+): Record<string, unknown> => {
+  if (type !== "table") return sanitizeShareData(data);
+
+  const tableDbKey =
+    typeof data.dbKey === "string" && data.dbKey.trim().length > 0
+      ? data.dbKey
+      : undefined;
+  const tableOwnerId =
+    typeof data.tenantId === "string" && data.tenantId.trim().length > 0
+      ? data.tenantId
+      : userId;
+
+  if (!tableDbKey) {
+    throw new Error("Table share requires a dbKey.");
+  }
+
+  return {
+    mode: "live",
+    tableDbKey,
+    tableOwnerId,
+    originServer,
+  };
+};
+
+export const shareResourceAction = async (
+  config: ShareActionConfig,
+  thunkApi: AppThunkApi
+): Promise<{ token: string; key: string }> => {
+  const state = thunkApi.getState();
+  const userId = selectUserId(state);
+  const currentUser = selectCurrentUser(state);
+
+  if (!userId) {
+    throw new Error("User must be logged in to share resources.");
+  }
+
+  const token = generateToken();
+  const key = shareKey.create(token);
+
+  const currentServer = selectCurrentServer(state);
+  assertDialogShareMessagesPresent(config.type, config.data);
+  const snapshotData = resolveTableSharePayload(
+    config.type,
+    config.data,
+    userId,
+    currentServer
+  );
+  const coverImage = extractCoverImage(config.type, snapshotData);
+  const agentInfo = extractAgentInfo(config.type, snapshotData);
+  const createdAt = Date.now();
+  const { db: clientDb } = thunkApi.extra;
+  let authorProfile: Record<string, unknown> | null = null;
+
+  if (clientDb) {
+    try {
+      authorProfile = await clientDb.get(createUserKey.profile(userId));
+    } catch {
+      authorProfile = null;
+    }
+  }
+
+  const { authorName, authorAvatar } = resolveShareAuthorIdentity({
+    user: currentUser as Record<string, unknown> | null,
+    profile: authorProfile,
+  });
+
+  // Resolve agent name from local DB if we have a key but no name
+  if (agentInfo.sourceAgentKey && !agentInfo.sourceAgentName) {
+    if (clientDb) {
+      try {
+        const agentData = await clientDb.get(agentInfo.sourceAgentKey);
+        const name = toNonEmptyString(agentData?.name);
+        if (name) agentInfo.sourceAgentName = name;
+      } catch { /* agent lookup is best-effort */ }
+    }
+  }
+
+  const sharedObject: SharedObject = {
+    type: config.type,
+    version: 1,
+    data: snapshotData,
+    meta: {
+      authorId: userId,
+      ...(authorName ? { authorName } : {}),
+      ...(authorAvatar ? { authorAvatar } : {}),
+      createdAt,
+      visibility: config.visibility ?? "private",
+      title: config.title,
+      description: config.description,
+      originalId: (config.data.dbKey ?? config.data.id) as string | undefined,
+      coverImage,
+      ...agentInfo,
+    },
+  };
+
+  const servers = [
+    currentServer,
+    ...selectRemoteServers(state).filter((server) => server !== currentServer),
+  ].filter(Boolean);
+  const replicaServers = servers.filter((server) => server !== currentServer);
+
+  if (servers.length === 0) {
+    throw new Error("No available server to publish share.");
+  }
+
+  if (config.type === "table" && sharedObject.data.mode === "live") {
+    sharedObject.data = {
+      ...sharedObject.data,
+      originServer: currentServer,
+    };
+    sharedObject.meta = {
+      ...sharedObject.meta,
+      mode: "live",
+      tableDbKey:
+        typeof sharedObject.data.tableDbKey === "string"
+          ? sharedObject.data.tableDbKey
+          : undefined,
+      tableOwnerId:
+        typeof sharedObject.data.tableOwnerId === "string"
+          ? sharedObject.data.tableOwnerId
+          : undefined,
+      originServer: currentServer,
+      replicaServers,
+    };
+  }
+
+  const persistedSharedObject = normalizeTimeFields({
+    ...sharedObject,
+    dbKey: key,
+    userId,
+  });
+
+  // Compute index keys on the frontend — server just stores them
+  const indexKeys = shareKey.allIndexKeysFromShare(key, persistedSharedObject);
+
+  const results = await Promise.all(
+    servers.map((server) =>
+      noloWriteRequest(server, { data: persistedSharedObject, customKey: key, userId, indexKeys }, state)
+    )
+  );
+  const [originPublished, ...replicaPublishResults] = results;
+
+  if (!originPublished) {
+    const successfulReplicaServers = replicaServers.filter(
+      (_, index) => replicaPublishResults[index]
+    );
+    await Promise.all(
+      successfulReplicaServers.map((server) =>
+        noloDeleteRequest(server, key, { type: "single" }, state)
+      )
+    );
+    throw new Error("Failed to publish share to origin server.");
+  }
+
+  if (!clientDb) {
+    throw new Error("Client database instance is required in shareResourceAction");
+  }
+  await clientDb.put(key, persistedSharedObject);
+
+  return { token, key };
+};