nolo-cli 0.1.23 → 0.1.29

package/server/billingLedgerRoutes.ts

@@ -0,0 +1,48 @@
+import { handleBillingLedgerAudit } from "./handlers/billingLedgerAuditHandler";
+import { handleBillingLedgerWitness } from "./handlers/billingLedgerWitnessHandler";
+import { handleBillingUsageReport } from "./handlers/billingUsageReportHandler";
+import { handleCreatorEarningsReport } from "./handlers/creatorEarningsReportHandler";
+import { handleCreatorSettlementReport } from "./handlers/creatorSettlementReportHandler";
+import { handleRevenueShareReport } from "./handlers/revenueShareReportHandler";
+
+const CORS_HEADERS: Record<string, string> = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers":
+    "Content-Type, Authorization, x-billing-ledger-audit-secret, x-billing-ledger-witness-secret",
+  "Access-Control-Max-Age": "86400",
+};
+
+const options = () => new Response(null, { status: 204, headers: CORS_HEADERS });
+
+export const billingLedgerRoutes: Record<string, any> = {
+  "/api/admin/billing-ledger/audit": {
+    GET: handleBillingLedgerAudit,
+    OPTIONS: options,
+  },
+  "/api/admin/billing-ledger/witness": {
+    GET: handleBillingLedgerWitness,
+    POST: handleBillingLedgerWitness,
+    OPTIONS: options,
+  },
+  "/api/admin/billing-ledger/witness/import": {
+    POST: handleBillingLedgerWitness,
+    OPTIONS: options,
+  },
+  "/api/admin/billing-usage/report": {
+    GET: handleBillingUsageReport,
+    OPTIONS: options,
+  },
+  "/api/admin/revenue-share/report": {
+    GET: handleRevenueShareReport,
+    OPTIONS: options,
+  },
+  "/api/admin/creator-earnings/report": {
+    GET: handleCreatorEarningsReport,
+    OPTIONS: options,
+  },
+  "/api/admin/creator-settlement/report": {
+    GET: handleCreatorSettlementReport,
+    OPTIONS: options,
+  },
+};

package/server/cliChatRoutes.ts

@@ -0,0 +1,5 @@
+import { handleCliChat } from "./handlers/cliChatHandler";
+
+export const cliChatRoutes: Record<string, any> = {
+  "/api/cli/chat": { POST: handleCliChat, OPTIONS: handleCliChat },
+};

package/server/cloudflareRoutes.ts

@@ -0,0 +1,35 @@
+import {
+  handleCloudflareCrawlStart,
+  handleCloudflareCrawlStatus,
+} from "./handlers/cloudflareCrawlHandler";
+import {
+  handleCfScreenshot,
+  handleCfMarkdown,
+  handleCfPdf,
+  handleCfJson,
+} from "./handlers/cloudflareBrowserHandler";
+import { handleCfSpeechToText } from "./handlers/cfWhisperHandler";
+import { handleCfTextToSpeech } from "./handlers/cfTextToSpeechHandler";
+
+const CORS_HEADERS: Record<string, string> = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Access-Control-Max-Age": "86400",
+};
+
+const options = () => new Response(null, { status: 204, headers: CORS_HEADERS });
+
+export const cloudflareRoutes: Record<string, any> = {
+  "/api/cloudflare-crawl": { POST: handleCloudflareCrawlStart, OPTIONS: options },
+  "/api/cloudflare-crawl/:jobId": {
+    GET: handleCloudflareCrawlStatus,
+    OPTIONS: options,
+  },
+  "/api/cf-screenshot": { POST: handleCfScreenshot, OPTIONS: options },
+  "/api/cf-markdown": { POST: handleCfMarkdown, OPTIONS: options },
+  "/api/cf-pdf": { POST: handleCfPdf, OPTIONS: options },
+  "/api/cf-json": { POST: handleCfJson, OPTIONS: options },
+  "/api/cf-speech-to-text": { POST: handleCfSpeechToText, OPTIONS: options },
+  "/api/cf-text-to-speech": { POST: handleCfTextToSpeech, OPTIONS: options },
+};

package/server/coreHeaders.ts

@@ -0,0 +1,29 @@
+export type NoloService = "core" | "preview";
+export type NoloOwner =
+  | "core-runtime"
+  | "core-route"
+  | "feature-route"
+  | "dev-tool";
+export type NoloRouteKind = "core" | "feature" | "tool";
+
+type ServiceHeaderMeta = {
+  service: NoloService;
+  owner: NoloOwner;
+  routeKind: NoloRouteKind;
+};
+
+export function withServiceHeaders(
+  response: Response,
+  meta: ServiceHeaderMeta
+): Response {
+  const headers = new Headers(response.headers);
+  headers.set("x-nolo-service", meta.service);
+  headers.set("x-nolo-owner", meta.owner);
+  headers.set("x-nolo-route-kind", meta.routeKind);
+
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}

package/server/coreReadiness.ts

@@ -0,0 +1,39 @@
+import { withServiceHeaders } from "./coreHeaders";
+import { getCoreRuntimeSnapshot } from "./coreRuntime";
+
+export function handleCoreReady(_req: Request) {
+  const snapshot = getCoreRuntimeSnapshot();
+  const body = {
+    ok: snapshot.ready,
+    ready: snapshot.ready,
+    status: snapshot.status,
+  };
+
+  return withServiceHeaders(
+    Response.json(body, {
+      status: snapshot.ready ? 200 : 503,
+    }),
+    {
+      service: "core",
+      owner: "core-runtime",
+      routeKind: "core",
+    }
+  );
+}
+
+export function handleCoreMeta(_req: Request) {
+  const snapshot = getCoreRuntimeSnapshot();
+
+  return withServiceHeaders(
+    Response.json({
+      service: "core",
+      status: snapshot.status,
+      ready: snapshot.ready,
+    }),
+    {
+      service: "core",
+      owner: "core-route",
+      routeKind: "core",
+    }
+  );
+}

package/server/coreRoutes.ts

@@ -0,0 +1,65 @@
+import { API_ENDPOINTS, API_VERSION } from "../database/config";
+
+import {
+  handleVersionDelete,
+  handleVersionGet,
+  handleVersionLabel,
+  handleVersionList,
+  handleVersionPin,
+  handleVersionRestore,
+  handleVersionSave,
+} from "./handlers/versionHandler";
+import {
+  handleDeleteUserSecret,
+  handleGetUserSecrets,
+  handleSetUserSecret,
+} from "./handlers/userSecretsHandler";
+import { handleWereadGateway } from "./handlers/wereadGatewayHandler";
+import { handleAppDomainAllow } from "./handlers/appDomainHandler";
+import { withServiceHeaders } from "./coreHeaders";
+import { handleCoreMeta, handleCoreReady } from "./coreReadiness";
+
+const CORS_HEADERS: Record<string, string> = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+  "Access-Control-Max-Age": "86400",
+};
+
+const options = () => new Response(null, { status: 204, headers: CORS_HEADERS });
+
+export const coreRoutes: Record<string, any> = {
+  "/health": () =>
+    withServiceHeaders(new Response("ok"), {
+      service: "core",
+      owner: "core-runtime",
+      routeKind: "core",
+    }),
+  "/ready": { GET: handleCoreReady },
+  "/api/core/meta": { GET: handleCoreMeta, OPTIONS: options },
+  [API_ENDPOINTS.HI]: {
+    GET: () =>
+      withServiceHeaders(
+        new Response(JSON.stringify({ API_VERSION }), {
+          headers: { "content-type": "application/json; charset=utf-8" },
+        }),
+        {
+          service: "core",
+          owner: "core-route",
+          routeKind: "core",
+        }
+      ),
+  },
+  "/api/version/save": { POST: handleVersionSave, OPTIONS: options },
+  "/api/version/list": { GET: handleVersionList, OPTIONS: options },
+  "/api/version/get": { GET: handleVersionGet, OPTIONS: options },
+  "/api/version/restore": { POST: handleVersionRestore, OPTIONS: options },
+  "/api/version/delete": { DELETE: handleVersionDelete, OPTIONS: options },
+  "/api/version/pin": { POST: handleVersionPin, OPTIONS: options },
+  "/api/version/label": { PATCH: handleVersionLabel, OPTIONS: options },
+  "/api/user-secrets": { GET: handleGetUserSecrets, OPTIONS: options },
+  "/api/user-secrets/set": { POST: handleSetUserSecret, OPTIONS: options },
+  "/api/user-secrets/delete": { POST: handleDeleteUserSecret, OPTIONS: options },
+  "/api/app/domain/allow": { GET: handleAppDomainAllow, OPTIONS: options },
+  "/api/weread/gateway": { POST: handleWereadGateway, OPTIONS: options },
+};

package/server/coreRuntime.ts

@@ -0,0 +1,93 @@
+import { closeAllUserSqliteDbs } from "../database/sqliteDb";
+import { closeServerDb, openServerDb } from "../database/server/db";
+import {
+  applyEmailRuntimeConfigFromDb,
+  startEmailRuntimeConfigSync,
+  stopEmailRuntimeConfigSync,
+} from "../auth/server/emailDbConfig";
+import {
+  startEmailAutomationScheduler,
+  stopEmailAutomationScheduler,
+} from "../auth/server/emailAutomation";
+import {
+  startEmailRetryScheduler,
+  stopEmailRetryScheduler,
+} from "../auth/server/emailDelivery";
+
+import {
+  startAgentTaskScheduler,
+  stopAgentTaskScheduler,
+} from "./scheduler/schedulerService";
+import {
+  startCryptoUsdcBaseWatcher,
+  stopCryptoUsdcBaseWatcher,
+} from "./payments/crypto/cryptoUsdcBaseWatcher";
+import {
+  startCryptoUsdtTronWatcher,
+  stopCryptoUsdtTronWatcher,
+} from "./payments/crypto/cryptoUsdtTronWatcher";
+
+type CoreRuntimeStatus = "idle" | "starting" | "ready" | "stopping";
+
+let status: CoreRuntimeStatus = "idle";
+let startPromise: Promise<void> | null = null;
+let stopPromise: Promise<void> | null = null;
+
+const backgroundWorkersDisabled = () =>
+  process.env.NOLO_DISABLE_BACKGROUND_WORKERS === "1";
+
+export function getCoreRuntimeSnapshot() {
+  return {
+    status,
+    ready: status === "ready",
+  };
+}
+
+export async function startCoreRuntime() {
+  if (startPromise) return startPromise;
+
+  startPromise = (async () => {
+    status = "starting";
+    await openServerDb();
+    await applyEmailRuntimeConfigFromDb();
+    if (backgroundWorkersDisabled()) {
+      status = "ready";
+      return;
+    }
+    startEmailRuntimeConfigSync();
+    startEmailAutomationScheduler();
+    startEmailRetryScheduler();
+    startAgentTaskScheduler();
+    startCryptoUsdcBaseWatcher();
+    startCryptoUsdtTronWatcher();
+    status = "ready";
+  })();
+
+  return startPromise;
+}
+
+export async function stopCoreRuntime() {
+  if (stopPromise) return stopPromise;
+
+  stopPromise = (async () => {
+    status = "stopping";
+    if (!backgroundWorkersDisabled()) {
+      stopEmailAutomationScheduler();
+      stopEmailRetryScheduler();
+      stopEmailRuntimeConfigSync();
+      stopAgentTaskScheduler();
+      stopCryptoUsdcBaseWatcher();
+      stopCryptoUsdtTronWatcher();
+    }
+    await closeServerDb();
+    closeAllUserSqliteDbs();
+    status = "idle";
+    startPromise = null;
+  })();
+
+  try {
+    await stopPromise;
+  } finally {
+    stopPromise = null;
+  }
+}

package/server/createResponse.ts

@@ -0,0 +1,68 @@
+export function createResponse() {
+  let response: Response | null = null;
+  let statusCode: number = 200;
+  let headers: Headers = new Headers();
+  function json(data: object) {
+    headers.set("Content-Type", "application/json");
+    // Add CORS headers
+    headers.set("Access-Control-Allow-Origin", "*");
+    headers.set(
+      "Access-Control-Allow-Methods",
+      "OPTIONS, GET, POST, PUT, DELETE,PATCH"
+    );
+    headers.set(
+      "Access-Control-Allow-Headers",
+      "Content-Type, Authorization, Accept, X-Requested-With"
+    );
+    headers.set("Access-Control-Max-Age", "1800");
+    headers.set("X-Frame-Options", "DENY");
+    headers.set("X-XSS-Protection", "1; mode=block");
+
+    response = new Response(JSON.stringify(data), {
+      status: statusCode,
+      headers: headers,
+    });
+    return response;
+  }
+
+  function status(code: number) {
+    statusCode = code;
+    return {
+      response,
+      status,
+      json,
+      setHeader,
+      write,
+      end,
+    };
+  }
+
+  function setHeader(name: string, value: string) {
+    headers.set(name, value);
+    return response;
+  }
+
+  function write(data: string) {
+    if (response) {
+      let text = response.body ? response.body.toString() + data : data;
+      response = new Response(text, {
+        status: statusCode,
+        headers: headers,
+      });
+    }
+    return response;
+  }
+
+  function end() {
+    return response;
+  }
+
+  return {
+    response,
+    status,
+    json,
+    setHeader,
+    write,
+    end,
+  };
+}

package/server/cryptoPaymentRoutes.ts

@@ -0,0 +1,8 @@
+import { createPaymentProviderRoutes } from "./payments/paymentRoutes";
+import { cryptoUsdcBasePaymentProvider } from "./payments/crypto/cryptoUsdcBasePaymentProvider";
+import { cryptoUsdtTronPaymentProvider } from "./payments/crypto/cryptoUsdtTronPaymentProvider";
+
+export const cryptoPaymentRoutes: Record<string, any> = {
+  ...createPaymentProviderRoutes(cryptoUsdcBasePaymentProvider),
+  ...createPaymentProviderRoutes(cryptoUsdtTronPaymentProvider),
+};

package/server/databaseRoutes.ts

@@ -0,0 +1,225 @@
+// 文件路径: databaseRoutes.ts
+import { API_ENDPOINTS } from "../database/config";
+import { handleReadSingle } from "../database/server/read";
+import { handleDelete } from "../database/server/delete";
+import { maybeProxyDatabaseRequestToCore } from "../database/server/coreDataProxy";
+import { handleUpload } from "../database/server/upload";
+import {
+  handleGetFileMetadata,
+  handleGetFileContent,
+  handleHeadFileContent,
+} from "../database/server/fileRead";
+import { handleCreatePage } from "../render/page/server/handleCreatePage";
+import { handleAppDeleteByKey } from "./handlers/appDeployMutationHandlers";
+import {
+  handleAddTableColumn,
+  handleAddTableRow,
+  handleAddTableRows,
+  handleCreateTable,
+  handleDeleteTableColumn,
+  handleDeleteTableRow,
+  handleDeleteTableRows,
+  handleQueryTableRows,
+  handleRenameTable,
+  handleRenameTableColumn,
+  handleRenameTableColumnLabel,
+  handleUpdateTableRow,
+  handleUpdateTableRows,
+} from "./handlers/tableToolHandlers";
+import { createRouteConfig } from "./routeFactory";
+
+export const databaseRouteConfigs = [
+  createRouteConfig({
+    path: `${API_ENDPOINTS.DATABASE}/read/:id`,
+    handlers: {
+      GET: async (req) => {
+        const url = new URL(req.url);
+        const proxied = await maybeProxyDatabaseRequestToCore({
+          req,
+          pathname: url.pathname,
+          search: url.search,
+          coreBaseUrl: process.env.NOLO_SERVER_CORE_BASE_URL,
+        });
+        if (proxied) {
+          return proxied;
+        }
+        return handleReadSingle(req);
+      },
+    },
+    allowedMethods: ["GET", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: `${API_ENDPOINTS.DATABASE}/delete/:id`,
+    handlers: {
+      DELETE: async (req) => {
+        const url = new URL(req.url);
+        const proxied = await maybeProxyDatabaseRequestToCore({
+          req,
+          pathname: url.pathname,
+          search: url.search,
+          coreBaseUrl: process.env.NOLO_SERVER_CORE_BASE_URL,
+        });
+        if (proxied) {
+          return proxied;
+        }
+        const id = (req as any).params?.id ?? "";
+        if (id.startsWith("app-")) {
+          return handleAppDeleteByKey(req, id);
+        }
+        return handleDelete(req);
+      },
+    },
+    allowedMethods: ["DELETE", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: `${API_ENDPOINTS.DATABASE}/upload`,
+    handlers: {
+      POST: async (req) => handleUpload(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  // 新增：获取文件元数据
+  createRouteConfig({
+    path: `${API_ENDPOINTS.DATABASE}/file/metadata/:id`,
+    handlers: {
+      GET: async (req) => handleGetFileMetadata(req),
+    },
+    allowedMethods: ["GET", "OPTIONS"],
+    enableCors: true,
+  }),
+  // 新增：获取文件内容（二进制）
+  createRouteConfig({
+    path: `${API_ENDPOINTS.DATABASE}/file/content/:id`,
+    handlers: {
+      GET: async (req) => handleGetFileContent(req),
+      HEAD: async (req) => handleHeadFileContent(req),
+    },
+    allowedMethods: ["GET", "HEAD", "OPTIONS"],
+    enableCors: true,
+  }),
+  // 新增：创建页面
+  createRouteConfig({
+    path: "/api/page/create",
+    handlers: {
+      POST: async (req) => handleCreatePage(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/create",
+    handlers: {
+      POST: async (req) => handleCreateTable(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/add-row",
+    handlers: {
+      POST: async (req) => handleAddTableRow(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/query-rows",
+    handlers: {
+      POST: async (req) => handleQueryTableRows(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/update-row",
+    handlers: {
+      POST: async (req) => handleUpdateTableRow(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/delete-row",
+    handlers: {
+      POST: async (req) => handleDeleteTableRow(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/add-rows",
+    handlers: {
+      POST: async (req) => handleAddTableRows(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/update-rows",
+    handlers: {
+      POST: async (req) => handleUpdateTableRows(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/delete-rows",
+    handlers: {
+      POST: async (req) => handleDeleteTableRows(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/add-column",
+    handlers: {
+      POST: async (req) => handleAddTableColumn(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/delete-column",
+    handlers: {
+      POST: async (req) => handleDeleteTableColumn(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/rename-column",
+    handlers: {
+      POST: async (req) => handleRenameTableColumn(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/rename-column-label",
+    handlers: {
+      POST: async (req) => handleRenameTableColumnLabel(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+  createRouteConfig({
+    path: "/api/table/rename",
+    handlers: {
+      POST: async (req) => handleRenameTable(req),
+    },
+    allowedMethods: ["POST", "OPTIONS"],
+    enableCors: true,
+  }),
+];
+
+// 将配置转为 apiRoutes 格式
+export const databaseRoutes = databaseRouteConfigs.reduce(
+  (acc, { path, route }) => {
+    acc[path] = route;
+    return acc;
+  },
+  {} as Record<string, any>
+);