nolo-cli 0.1.23 → 0.1.29

package/server/email/cloudflareEmailProvider.ts

@@ -0,0 +1,119 @@
+import {
+  parseGenericInboundPayload,
+  type EmailProvider,
+  type EmailProviderSendInput,
+  type EmailProviderSendResult,
+} from "./provider";
+
+type CloudflareEmailProviderConfig = {
+  accountId: string;
+  apiToken: string;
+  webhookSecret?: string;
+  apiBaseUrl?: string;
+};
+
+const participantToCloudflareAddress = (participant: { email: string; name?: string }) =>
+  participant.name
+    ? { address: participant.email, name: participant.name }
+    : participant.email;
+
+const participantsToEmails = (participants?: { email: string }[]) =>
+  Array.isArray(participants)
+    ? participants.map((participant) => participant.email).filter(Boolean)
+    : undefined;
+
+const responseErrorText = (payload: any, fallback: string): string => {
+  const errors = Array.isArray(payload?.errors)
+    ? payload.errors
+        .map((error: any) => error?.message || error?.code)
+        .filter(Boolean)
+    : [];
+  if (errors.length > 0) return errors.join("; ");
+  return fallback;
+};
+
+const resultStatus = (payload: any): EmailProviderSendResult["status"] => {
+  const delivered = Array.isArray(payload?.result?.delivered)
+    ? payload.result.delivered
+    : [];
+  const queued = Array.isArray(payload?.result?.queued) ? payload.result.queued : [];
+  if (delivered.length === 0 && queued.length > 0) return "queued";
+  return "sent";
+};
+
+export function createCloudflareEmailProvider(
+  config: CloudflareEmailProviderConfig
+): EmailProvider {
+  const apiBaseUrl =
+    config.apiBaseUrl?.replace(/\/+$/, "") ||
+    "https://api.cloudflare.com/client/v4";
+
+  return {
+    name: "cloudflare",
+    async sendEmail(input: EmailProviderSendInput): Promise<EmailProviderSendResult> {
+      const response = await fetch(
+        `${apiBaseUrl}/accounts/${encodeURIComponent(config.accountId)}/email/sending/send`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${config.apiToken}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({
+            from: participantToCloudflareAddress(input.from),
+            to: participantsToEmails(input.to),
+            cc: participantsToEmails(input.cc),
+            bcc: participantsToEmails(input.bcc),
+            reply_to: input.replyTo?.[0]
+              ? participantToCloudflareAddress(input.replyTo[0])
+              : undefined,
+            subject: input.subject,
+            text: input.text,
+            html: input.html,
+            headers: input.headers,
+          }),
+        }
+      );
+
+      const text = await response.text();
+      let payload: any = null;
+      try {
+        payload = text ? JSON.parse(text) : null;
+      } catch {
+        payload = { rawText: text };
+      }
+
+      if (!response.ok || payload?.success === false) {
+        return {
+          status: "failed",
+          error: responseErrorText(payload, `Cloudflare Email API HTTP ${response.status}`),
+          raw: payload,
+        };
+      }
+
+      const result = payload?.result || {};
+      return {
+        status: resultStatus(payload),
+        providerMessageId:
+          typeof result.message_id === "string"
+            ? result.message_id
+            : typeof result.messageId === "string"
+              ? result.messageId
+              : undefined,
+        delivered: Array.isArray(result.delivered) ? result.delivered : [],
+        queued: Array.isArray(result.queued) ? result.queued : [],
+        permanentBounces: Array.isArray(result.permanent_bounces)
+          ? result.permanent_bounces
+          : [],
+        raw: payload,
+      };
+    },
+    async verifyWebhook(request: Request) {
+      if (!config.webhookSecret) return false;
+      return request.headers.get("x-email-webhook-secret") === config.webhookSecret;
+    },
+    async parseInbound(payload: unknown) {
+      return parseGenericInboundPayload(payload);
+    },
+  };
+}

package/server/email/cloudflareInboundBridge.ts

@@ -0,0 +1,121 @@
+type EmailParticipant = {
+  email: string;
+  name?: string;
+};
+
+type CloudflareInboundAddressable = {
+  from?: string;
+  to?: string | string[];
+  headers?: Headers;
+  raw?: ReadableStream | string | ArrayBuffer | Uint8Array;
+};
+
+type BuildCloudflareInboundPayloadOptions = {
+  receivedAt: string;
+  html?: string;
+};
+
+type ForwardCloudflareInboundEmailOptions = BuildCloudflareInboundPayloadOptions & {
+  webhookUrl: string;
+  webhookSecret: string;
+  fetchImpl?: typeof fetch;
+};
+
+type GenericInboundPayload = {
+  from: EmailParticipant;
+  to: EmailParticipant[];
+  cc: EmailParticipant[];
+  bcc: EmailParticipant[];
+  replyTo: EmailParticipant[];
+  subject: string;
+  text?: string;
+  html?: string;
+  messageId?: string;
+  rawHeaders?: Record<string, string>;
+  providerReceivedAt: string;
+};
+
+const parseMailbox = (value: string | null | undefined): EmailParticipant | null => {
+  const text = value?.trim();
+  if (!text) return null;
+  const match = text.match(/^(.*?)<([^>]+)>$/);
+  if (!match) return { email: text };
+  const name = match[1]?.trim().replace(/^"|"$/g, "");
+  const email = match[2]?.trim();
+  if (!email) return null;
+  return name ? { email, name } : { email };
+};
+
+const splitMailboxList = (value: string | null | undefined): EmailParticipant[] =>
+  (value || "")
+    .split(",")
+    .map((part) => parseMailbox(part))
+    .filter((item): item is EmailParticipant => Boolean(item));
+
+const readRawText = async (raw: CloudflareInboundAddressable["raw"]): Promise<string> => {
+  if (typeof raw === "string") return raw;
+  if (raw instanceof Uint8Array) return new TextDecoder().decode(raw);
+  if (raw instanceof ArrayBuffer) return new TextDecoder().decode(new Uint8Array(raw));
+  if (raw && typeof (raw as ReadableStream).getReader === "function") {
+    return await new Response(raw as ReadableStream).text();
+  }
+  return "";
+};
+
+export async function buildCloudflareInboundPayload(
+  message: CloudflareInboundAddressable,
+  options: BuildCloudflareInboundPayloadOptions
+): Promise<GenericInboundPayload> {
+  const from = parseMailbox(message.from);
+  const directRecipients = Array.isArray(message.to)
+    ? message.to.flatMap((value) => splitMailboxList(value))
+    : splitMailboxList(message.to);
+  const to =
+    directRecipients.length > 0 ? directRecipients : splitMailboxList(message.headers?.get("to"));
+  if (!from) throw new Error("Cloudflare inbound message requires a sender address");
+  if (to.length === 0) {
+    throw new Error("Cloudflare inbound message requires at least one recipient address");
+  }
+
+  const rawHeaders = Object.fromEntries(
+    ["message-id", "date"]
+      .map((name) => [name, message.headers?.get(name) || ""] as const)
+      .filter(([, value]) => value)
+  );
+
+  return {
+    from,
+    to,
+    cc: splitMailboxList(message.headers?.get("cc")),
+    bcc: splitMailboxList(message.headers?.get("bcc")),
+    replyTo: splitMailboxList(message.headers?.get("reply-to")),
+    subject: message.headers?.get("subject") || "",
+    text: await readRawText(message.raw),
+    html: options.html,
+    messageId: message.headers?.get("message-id") || undefined,
+    rawHeaders: Object.keys(rawHeaders).length > 0 ? rawHeaders : undefined,
+    providerReceivedAt: options.receivedAt,
+  };
+}
+
+export async function forwardCloudflareInboundEmail(
+  message: CloudflareInboundAddressable,
+  options: ForwardCloudflareInboundEmailOptions
+): Promise<Response> {
+  const payload = await buildCloudflareInboundPayload(message, options);
+  const response = await (options.fetchImpl || fetch)(options.webhookUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-email-webhook-secret": options.webhookSecret,
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Inbound webhook HTTP ${response.status}: ${body.slice(0, 200)}`);
+  }
+
+  return response;
+}

package/server/email/cloudflareInboundWorker.ts

@@ -0,0 +1,28 @@
+import { forwardCloudflareInboundEmail } from "./cloudflareInboundBridge";
+
+export type CloudflareInboundWorkerEnv = {
+  EMAIL_INBOUND_WEBHOOK_URL: string;
+  EMAIL_WEBHOOK_SECRET: string;
+};
+
+type ForwardableEmailMessage = {
+  from?: string;
+  to?: string | string[];
+  headers?: Headers;
+  raw?: ReadableStream | string | ArrayBuffer | Uint8Array;
+};
+
+const required = (value: string | undefined, name: string) => {
+  if (!value) throw new Error(`${name} is required`);
+  return value;
+};
+
+export default {
+  async email(message: ForwardableEmailMessage, env: CloudflareInboundWorkerEnv) {
+    await forwardCloudflareInboundEmail(message, {
+      webhookUrl: required(env.EMAIL_INBOUND_WEBHOOK_URL, "EMAIL_INBOUND_WEBHOOK_URL"),
+      webhookSecret: required(env.EMAIL_WEBHOOK_SECRET, "EMAIL_WEBHOOK_SECRET"),
+      receivedAt: new Date().toISOString(),
+    });
+  },
+};

package/server/email/provider.ts

@@ -0,0 +1,149 @@
+import type { EmailParticipant } from "../../database/email";
+
+export type EmailSendStatus = "sent" | "queued" | "failed";
+
+export type EmailProviderSendInput = {
+  from: EmailParticipant;
+  to: EmailParticipant[];
+  cc?: EmailParticipant[];
+  bcc?: EmailParticipant[];
+  replyTo?: EmailParticipant[];
+  subject: string;
+  text?: string;
+  html?: string;
+  headers?: Record<string, string>;
+};
+
+export type EmailProviderSendResult = {
+  status: EmailSendStatus;
+  providerMessageId?: string;
+  delivered?: string[];
+  queued?: string[];
+  permanentBounces?: string[];
+  raw?: unknown;
+  error?: string;
+};
+
+export type EmailProviderInboundPayload = {
+  from: EmailParticipant;
+  to: EmailParticipant[];
+  cc?: EmailParticipant[];
+  bcc?: EmailParticipant[];
+  replyTo?: EmailParticipant[];
+  subject: string;
+  text?: string;
+  html?: string;
+  messageId?: string;
+  rawHeaders?: Record<string, string>;
+  providerReceivedAt?: string;
+  providerMessageId?: string;
+  raw?: unknown;
+};
+
+export type EmailProvider = {
+  name: string;
+  sendEmail(input: EmailProviderSendInput): Promise<EmailProviderSendResult>;
+  verifyWebhook(request: Request): Promise<boolean>;
+  parseInbound(payload: unknown): Promise<EmailProviderInboundPayload>;
+};
+
+export type MockEmailProviderOptions = {
+  sendResult?: Partial<EmailProviderSendResult>;
+  failMessage?: string;
+  webhookSecret?: string;
+};
+
+const normalizeAddress = (value: unknown): EmailParticipant | null => {
+  if (typeof value === "string" && value.trim()) {
+    return { email: value.trim() };
+  }
+  if (!value || typeof value !== "object") return null;
+  const raw = value as Record<string, unknown>;
+  const email = typeof raw.email === "string"
+    ? raw.email.trim()
+    : typeof raw.address === "string"
+      ? raw.address.trim()
+      : "";
+  if (!email) return null;
+  const name = typeof raw.name === "string" && raw.name.trim()
+    ? raw.name.trim()
+    : undefined;
+  return { email, ...(name ? { name } : {}) };
+};
+
+const normalizeAddressList = (value: unknown): EmailParticipant[] => {
+  if (!Array.isArray(value)) {
+    const single = normalizeAddress(value);
+    return single ? [single] : [];
+  }
+  return value
+    .map(normalizeAddress)
+    .filter((item): item is EmailParticipant => Boolean(item));
+};
+
+export const parseGenericInboundPayload = (
+  payload: unknown
+): EmailProviderInboundPayload => {
+  if (!payload || typeof payload !== "object") {
+    throw new Error("Inbound email payload must be an object");
+  }
+
+  const raw = payload as Record<string, unknown>;
+  const from = normalizeAddress(raw.from);
+  const to = normalizeAddressList(raw.to);
+  if (!from) throw new Error("Inbound email payload requires from");
+  if (to.length === 0) throw new Error("Inbound email payload requires to");
+
+  return {
+    from,
+    to,
+    cc: normalizeAddressList(raw.cc),
+    bcc: normalizeAddressList(raw.bcc),
+    replyTo: normalizeAddressList(raw.replyTo ?? raw.reply_to),
+    subject: typeof raw.subject === "string" ? raw.subject : "",
+    text: typeof raw.text === "string" ? raw.text : undefined,
+    html: typeof raw.html === "string" ? raw.html : undefined,
+    messageId: typeof raw.messageId === "string" ? raw.messageId : undefined,
+    rawHeaders:
+      raw.rawHeaders && typeof raw.rawHeaders === "object" && !Array.isArray(raw.rawHeaders)
+        ? raw.rawHeaders as Record<string, string>
+        : undefined,
+    providerReceivedAt:
+      typeof raw.providerReceivedAt === "string" ? raw.providerReceivedAt : undefined,
+    providerMessageId:
+      typeof raw.providerMessageId === "string" ? raw.providerMessageId : undefined,
+    raw,
+  };
+};
+
+export function createMockEmailProvider(
+  options: MockEmailProviderOptions = {}
+): EmailProvider {
+  return {
+    name: "mock",
+    async sendEmail(input) {
+      if (options.failMessage) {
+        return {
+          status: "failed",
+          error: options.failMessage,
+          raw: { provider: "mock", input },
+          ...options.sendResult,
+        };
+      }
+      return {
+        status: "sent",
+        providerMessageId: `mock-${Date.now()}`,
+        delivered: input.to.map((recipient) => recipient.email),
+        raw: { provider: "mock", input },
+        ...options.sendResult,
+      };
+    },
+    async verifyWebhook(request) {
+      if (!options.webhookSecret) return true;
+      return request.headers.get("x-email-webhook-secret") === options.webhookSecret;
+    },
+    async parseInbound(payload) {
+      return parseGenericInboundPayload(payload);
+    },
+  };
+}

package/server/email/providerRegistry.ts

@@ -0,0 +1,22 @@
+import { createCloudflareEmailProvider } from "./cloudflareEmailProvider";
+import { createMockEmailProvider, type EmailProvider } from "./provider";
+
+export function getEmailProvider(env: NodeJS.ProcessEnv = process.env): EmailProvider {
+  const provider = String(env.EMAIL_PROVIDER || "mock").trim().toLowerCase();
+  if (provider === "cloudflare") {
+    const accountId = String(env.CLOUDFLARE_ACCOUNT_ID || "").trim();
+    const apiToken = String(env.CLOUDFLARE_EMAIL_API_TOKEN || "").trim();
+    if (!accountId || !apiToken) {
+      throw new Error(
+        "EMAIL_PROVIDER=cloudflare requires CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_EMAIL_API_TOKEN"
+      );
+    }
+    return createCloudflareEmailProvider({
+      accountId,
+      apiToken,
+      webhookSecret: String(env.EMAIL_WEBHOOK_SECRET || "").trim() || undefined,
+    });
+  }
+
+  return createMockEmailProvider();
+}

package/server/emailInboundRoutes.ts

@@ -0,0 +1,17 @@
+import { handleCloudflareInboundEmail } from "./handlers/emailInboundHandler";
+
+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 emailInboundRoutes: Record<string, any> = {
+  "/api/email/inbound/cloudflare": {
+    POST: handleCloudflareInboundEmail,
+    OPTIONS: options,
+  },
+};

package/server/entry.ts

@@ -0,0 +1,211 @@
+// 文件路径: packages/server/entry.ts
+// 只负责启动服务器；路由定义见 routes.ts
+// Phase 3 note:
+// This entry still boots both shared web/server responsibilities and
+// desktop-embedded runtime responsibilities. Desktop currently reuses it as a
+// transition step. The intended end state is to split this into:
+// - shared remote/web server entry
+// - narrower desktop runtime entry
+// so desktop does not keep inheriting unrelated schedulers and authority work.
+
+import { serve, file as bunFile } from "bun";
+import { existsSync } from "node:fs";
+
+import { isProduction } from "../app/utils/env";
+import { startCoreRuntime, stopCoreRuntime } from "./coreRuntime";
+import { handleRequest } from "./handleRequest";
+import { apiRoutes } from "./routes";
+import { ENABLE_LIVE_RELOAD } from "./devReload";
+import { resolvePreviewConfig } from "./preview/previewConfig";
+import {
+  handleConnectorClose,
+  handleConnectorMessage,
+  handleConnectorOpen,
+} from "./handlers/connector/connectorWebSocket";
+ 
+import {
+  getActiveRequestCount,
+  getActiveStreamCount,
+  trackRequest,
+  waitForServerDrain,
+  wrapRoutesWithRequestTracking,
+} from "./serverDrain";
+
+const HTTP_PORT = Number(process.env.HTTP_PORT ?? 80);
+const HTTPS_PORT = 443;
+const HTTP_HOST = process.env.PLATFORM_SERVER_HOST ?? "0.0.0.0";
+const isDesktopMode = process.env.NOLO_DESKTOP === "1";
+const disableHttps = process.env.NOLO_DISABLE_HTTPS === "1" || process.env.DISABLE_HTTPS === "1";
+const TLS_KEY_PATH = process.env.NOLO_TLS_KEY_PATH ?? "./key.pem";
+const TLS_CERT_PATH = process.env.NOLO_TLS_CERT_PATH ?? "./cert.pem";
+const previewConfig = resolvePreviewConfig(process.env);
+
+const createServerOptions = () => ({
+  routes: wrapRoutesWithRequestTracking(apiRoutes),
+  idleTimeout: 0,
+  hostname: HTTP_HOST,
+  fetch: trackRequest(handleRequest),
+  websocket: {
+    open: (ws: any) => {
+      handleConnectorOpen(ws);
+    },
+    message: (ws: any, message: string | Buffer) => {
+      if (!handleConnectorMessage(ws, message)) {
+        ws.send("Received");
+      }
+    },
+    close: (ws: any) => {
+      handleConnectorClose(ws);
+    },
+  },
+});
+
+let httpServer: any = null;
+let httpsServer: any = null;
+let bootPromise: Promise<void> | null = null;
+let shutdownPromise: Promise<void> | null = null;
+let processHooksRegistered = false;
+
+const startHttpServer = () => {
+  httpServer = serve({ ...createServerOptions(), port: HTTP_PORT });
+  (globalThis as any).__httpServer = httpServer;
+  console.log(`HTTP server started on ${HTTP_HOST}:${HTTP_PORT}`);
+  if (previewConfig.enabled) {
+    console.log(
+      `[preview] slot=${previewConfig.slot.slug} hosts=${previewConfig.slot.hosts.join(",")} fallback=${previewConfig.slot.fallbackOrigin} owned=${previewConfig.slot.ownedCapabilities.join(",")}`
+    );
+  }
+};
+
+const startHttpsServer = () => {
+  if (disableHttps) {
+    console.log("HTTPS server not started (disabled by NOLO_DISABLE_HTTPS)");
+    return;
+  }
+
+  if (!isProduction) {
+    console.log("HTTPS server not started (not in production mode)");
+    return;
+  }
+
+  if (isDesktopMode) {
+    console.log("HTTPS server not started (desktop mode uses local HTTP only)");
+    return;
+  }
+
+  if (!existsSync(TLS_KEY_PATH) || !existsSync(TLS_CERT_PATH)) {
+    console.warn(
+      `HTTPS server not started (missing TLS files: key=${TLS_KEY_PATH}, cert=${TLS_CERT_PATH})`
+    );
+    return;
+  }
+
+  httpsServer = serve({
+    ...createServerOptions(),
+    port: HTTPS_PORT,
+    tls: {
+      key: bunFile(TLS_KEY_PATH),
+      cert: bunFile(TLS_CERT_PATH),
+    },
+  });
+
+  console.log(`HTTPS server started on ${HTTP_HOST}:${HTTPS_PORT}`);
+};
+
+const registerProcessSafetyNet = () => {
+  if (typeof process === "undefined") return;
+
+  process.on("uncaughtException", (err: any) => {
+    console.error("[UncaughtException]", err);
+    process.exit(1);
+  });
+
+  process.on("unhandledRejection", (reason: any) => {
+    console.error("[UnhandledRejection]", reason);
+    process.exit(1);
+  });
+};
+
+const registerGracefulShutdown = () => {
+  if (typeof process === "undefined") return;
+  if (processHooksRegistered) return;
+  processHooksRegistered = true;
+
+  const shutdown = async (signal: string) => {
+    console.log(`[${signal}] Received, starting graceful shutdown...`);
+
+    try {
+      await shutdownServer(signal);
+      console.log("Servers & DBs stopped. Exiting process.");
+    } catch (err) {
+      console.error("Error during shutdown:", err);
+    } finally {
+      process.exit(0);
+    }
+  };
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+};
+
+export const bootstrapServer = async () => {
+  if (bootPromise) return bootPromise;
+
+  bootPromise = (async () => {
+  console.log("isProduction:", isProduction, "ENABLE_LIVE_RELOAD:", ENABLE_LIVE_RELOAD);
+  await startCoreRuntime();
+  registerProcessSafetyNet();
+  startHttpServer();
+  startHttpsServer();
+  if (process.env.NOLO_SERVER_REGISTER_PROCESS_HANDLERS !== "0") {
+    registerGracefulShutdown();
+  }
+  })();
+
+  return bootPromise;
+};
+
+export const shutdownServer = async (_reason = "manual") => {
+  if (shutdownPromise) return shutdownPromise;
+
+  shutdownPromise = (async () => {
+    // 停止接受新连接，保留已有连接继续处理
+    httpServer?.stop(false);
+    httpsServer?.stop(false);
+    httpServer = null;
+    httpsServer = null;
+
+    // 等待所有 in-flight request + 脱离请求生命周期的后台流式任务排空（最多 30s）。
+    const requestCount = getActiveRequestCount();
+    const streamCount = getActiveStreamCount();
+    if (requestCount > 0 || streamCount > 0) {
+      console.log(
+        `[shutdown] waiting for active work (requests=${requestCount}, backgroundStreams=${streamCount}, max 30s)...`
+      );
+      await waitForServerDrain(30_000);
+      console.log("[shutdown] active work drained");
+    }
+    await stopCoreRuntime();
+    bootPromise = null;
+  })();
+
+  try {
+    await shutdownPromise;
+  } finally {
+    shutdownPromise = null;
+  }
+};
+
+// --hot 模式：模块热替换时只 reload handler，不重建 server 实例，保持已有连接
+if (import.meta.hot) {
+  if (!(globalThis as any).__serverBootstrapped) {
+    (globalThis as any).__serverBootstrapped = true;
+    bootstrapServer();
+  } else {
+    (globalThis as any).__httpServer?.reload(createServerOptions());
+    console.log("[hot] server reloaded, existing connections kept alive");
+  }
+  import.meta.hot.accept();
+} else if (process.env.NOLO_SERVER_AUTOSTART !== "0") {
+  bootstrapServer();
+}