nolo-cli 0.1.23 → 0.1.29

package/server/payments/waffo/waffoPaymentProvider.ts

@@ -0,0 +1,341 @@
+import {
+  Environment,
+  TaxCategory,
+  WaffoPancake,
+  WaffoPancakeError,
+  WebhookEventType,
+  type WebhookEventData,
+  type WebhookPublicKeys,
+} from "@waffo/pancake-ts";
+import { ulid } from "ulid";
+import { CORS_HEADERS_AUTH } from "../../../auth/utils";
+import { handleToken } from "../../../auth/server/token";
+import { rechargeUserBalance } from "../../../auth/server/recharge";
+import serverDb from "../../../database/server/db";
+import { createResponse } from "../../createResponse";
+import type { PaymentProvider } from "../paymentProvider";
+import {
+  getRechargeCreditLimits,
+  validateRechargeCredits,
+} from "../rechargeCredits";
+
+const WAFFO_PAYMENT_PREFIX = "payment-waffo-";
+const DEFAULT_MERCHANT_ID = "MER_6yxk9A3HK0Ka7j2kHRaE1L";
+const WAFFO_RECHARGE_LIMIT_KEYS = {
+  minCreditsEnv: "WAFFO_MIN_CREDITS",
+  maxCreditsEnv: "WAFFO_MAX_CREDITS",
+};
+
+type WaffoPaymentRecord = {
+  provider: "waffo_pancake";
+  paymentRequestId: string;
+  sessionId?: string;
+  checkoutUrl?: string;
+  userId: string;
+  username?: string;
+  email?: string;
+  credits: number;
+  orderAmount: string;
+  orderCurrency: string;
+  status: "created" | "pending" | "paid" | "closed" | "failed";
+  createdAt: number;
+  updatedAt: number;
+  raw?: unknown;
+};
+
+const jsonResponse = (body: unknown, status = 200, headers?: HeadersInit) =>
+  new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      ...CORS_HEADERS_AUTH,
+      ...headers,
+    },
+  });
+
+const jsonError = (
+  status: number,
+  message: string,
+  code: string,
+  details?: unknown
+) => jsonResponse({ error: { message, code, details } }, status);
+
+const paymentKey = (paymentRequestId: string) =>
+  `${WAFFO_PAYMENT_PREFIX}${paymentRequestId}`;
+
+const getMerchantId = () =>
+  process.env.WAFFO_MERCHANT_ID?.trim() || DEFAULT_MERCHANT_ID;
+
+const getProductId = () => process.env.WAFFO_PRODUCT_ID?.trim() || "";
+
+const getWaffoEnvironment = () => {
+  const value = (process.env.WAFFO_ENVIRONMENT || "test").trim().toLowerCase();
+  return value === "prod" || value === "production"
+    ? Environment.Prod
+    : Environment.Test;
+};
+
+const getPublicBaseUrl = (request: Request) => {
+  const configured =
+    process.env.WAFFO_PUBLIC_BASE_URL ||
+    process.env.PUBLIC_APP_URL ||
+    process.env.APP_URL;
+  if (configured?.trim()) return configured.trim().replace(/\/+$/, "");
+  return new URL(request.url).origin;
+};
+
+const getCreditsPerCurrencyUnit = () => {
+  const value = Number(process.env.WAFFO_CREDITS_PER_CURRENCY_UNIT ?? "1");
+  return Number.isFinite(value) && value > 0 ? value : 1;
+};
+
+const getOrderCurrency = () =>
+  (process.env.WAFFO_RECHARGE_CURRENCY || "USD").trim().toUpperCase();
+
+export const getWaffoRechargeLimits = () =>
+  getRechargeCreditLimits(WAFFO_RECHARGE_LIMIT_KEYS);
+
+export const validateWaffoRechargeCredits = (
+  value: unknown
+) => validateRechargeCredits(value, WAFFO_RECHARGE_LIMIT_KEYS);
+
+const getWebhookPublicKeys = (): WebhookPublicKeys | undefined => {
+  const test = process.env.WAFFO_WEBHOOK_TEST_PUBLIC_KEY?.trim();
+  const prod = process.env.WAFFO_WEBHOOK_PROD_PUBLIC_KEY?.trim();
+  const shared = process.env.WAFFO_WEBHOOK_PUBLIC_KEY?.trim();
+  if (test || prod) return { test, prod };
+  return shared;
+};
+
+export const isWaffoConfigured = () =>
+  Boolean(getMerchantId() && process.env.WAFFO_PRIVATE_KEY?.trim() && getProductId());
+
+const getWaffoClient = () => {
+  const privateKey = process.env.WAFFO_PRIVATE_KEY?.trim();
+  if (!privateKey) throw new Error("WAFFO_PRIVATE_KEY is not configured");
+
+  const webhookPublicKey = getWebhookPublicKeys();
+  return new WaffoPancake({
+    merchantId: getMerchantId(),
+    privateKey,
+    ...(process.env.WAFFO_API_BASE_URL?.trim()
+      ? { baseUrl: process.env.WAFFO_API_BASE_URL.trim().replace(/\/+$/, "") }
+      : {}),
+    ...(webhookPublicKey ? { webhookPublicKey } : {}),
+  });
+};
+
+const toAmountString = (credits: number) =>
+  (Math.round((credits / getCreditsPerCurrencyUnit()) * 100) / 100).toFixed(2);
+
+const getBuyerEmail = (user: any) =>
+  typeof user?.email === "string" && user.email.trim()
+    ? user.email.trim()
+    : undefined;
+
+export const handleWaffoConfig = async () =>
+  jsonResponse({
+    configured: isWaffoConfigured(),
+    currency: getOrderCurrency(),
+    creditsPerCurrencyUnit: getCreditsPerCurrencyUnit(),
+    environment: getWaffoEnvironment(),
+    ...getWaffoRechargeLimits(),
+    merchantIdConfigured: Boolean(getMerchantId()),
+    productIdConfigured: Boolean(getProductId()),
+  });
+
+export const handleCreateWaffoOrder = async (req: Request) => {
+  if (!isWaffoConfigured()) {
+    return jsonError(
+      503,
+      "Waffo Pancake payment is not configured.",
+      "WAFFO_NOT_CONFIGURED",
+      {
+        needs: ["WAFFO_PRIVATE_KEY", "WAFFO_PRODUCT_ID"],
+      }
+    );
+  }
+
+  const authResult = await handleToken(req, createResponse());
+  if (authResult instanceof Response) return authResult;
+
+  let body: any = {};
+  try {
+    body = await req.json();
+  } catch {
+    return jsonError(400, "Invalid JSON body.", "INVALID_JSON");
+  }
+
+  const validation = validateWaffoRechargeCredits(body?.credits ?? body?.amount);
+  if (!validation.ok) {
+    return jsonError(
+      400,
+      validation.message,
+      validation.code,
+      validation.details
+    );
+  }
+  const { credits } = validation;
+
+  const userId = String(authResult.userId || "");
+  const user = await serverDb.get(`user:${userId}`).catch(() => null);
+  const username =
+    typeof user?.username === "string"
+      ? user.username
+      : typeof (authResult as any).username === "string"
+        ? (authResult as any).username
+        : undefined;
+  const email = getBuyerEmail(user);
+
+  const paymentRequestId = ulid();
+  const orderCurrency = getOrderCurrency();
+  const orderAmount = toAmountString(credits);
+  const publicBaseUrl = getPublicBaseUrl(req);
+  const now = Date.now();
+  const metadata = {
+    provider: "waffo_pancake",
+    paymentRequestId,
+    userId,
+    credits: String(credits),
+  };
+
+  try {
+    const result = await getWaffoClient().checkout.authenticated.create({
+      productId: getProductId(),
+      currency: orderCurrency,
+      buyerIdentity: userId,
+      ...(email ? { buyerEmail: email } : {}),
+      priceSnapshot: {
+        amount: orderAmount,
+        taxCategory: TaxCategory.DigitalGoods,
+      },
+      metadata,
+      successUrl: `${publicBaseUrl}/recharge?waffo=success&paymentRequestId=${paymentRequestId}`,
+    });
+
+    const record: WaffoPaymentRecord = {
+      provider: "waffo_pancake",
+      paymentRequestId,
+      sessionId: result.sessionId,
+      checkoutUrl: result.checkoutUrl,
+      userId,
+      username,
+      email,
+      credits,
+      orderAmount,
+      orderCurrency,
+      status: "pending",
+      createdAt: now,
+      updatedAt: Date.now(),
+      raw: {
+        sessionId: result.sessionId,
+        expiresAt: result.expiresAt,
+        tokenExpiresAt: result.tokenExpiresAt,
+      },
+    };
+    await serverDb.put(paymentKey(paymentRequestId), record);
+
+    return jsonResponse({
+      success: true,
+      provider: "waffo_pancake",
+      paymentRequestId,
+      sessionId: result.sessionId,
+      checkoutUrl: result.checkoutUrl,
+      redirectUrl: result.checkoutUrl,
+      expiresAt: result.expiresAt,
+    });
+  } catch (error) {
+    if (error instanceof WaffoPancakeError) {
+      return jsonError(
+        502,
+        error.message || "Failed to create Waffo Pancake checkout.",
+        "WAFFO_CREATE_CHECKOUT_FAILED",
+        { status: error.status, errors: error.errors }
+      );
+    }
+    return jsonError(
+      502,
+      error instanceof Error
+        ? error.message
+        : "Failed to create Waffo Pancake checkout.",
+      "WAFFO_CREATE_CHECKOUT_FAILED"
+    );
+  }
+};
+
+export const handleWaffoWebhook = async (req: Request) => {
+  if (!isWaffoConfigured()) {
+    return new Response("Waffo Pancake payment is not configured", {
+      status: 503,
+      headers: CORS_HEADERS_AUTH,
+    });
+  }
+
+  const body = await req.text();
+  const signature = req.headers.get("X-Waffo-Signature");
+  let event;
+  try {
+    event = getWaffoClient().webhooks.verify<WebhookEventData>(
+      body,
+      signature,
+      { environment: getWaffoEnvironment() }
+    );
+  } catch {
+    return new Response("Invalid signature", {
+      status: 401,
+      headers: CORS_HEADERS_AUTH,
+    });
+  }
+
+  if (event.eventType !== WebhookEventType.OrderCompleted) {
+    return new Response("OK", { status: 200, headers: CORS_HEADERS_AUTH });
+  }
+
+  const paymentRequestId = event.data.orderMetadata?.paymentRequestId;
+  if (!paymentRequestId) {
+    return new Response("Missing paymentRequestId", {
+      status: 400,
+      headers: CORS_HEADERS_AUTH,
+    });
+  }
+
+  const key = paymentKey(paymentRequestId);
+  const record = (await serverDb.get(key).catch(() => null)) as
+    | WaffoPaymentRecord
+    | null;
+  if (!record) {
+    return new Response("Payment record not found", {
+      status: 404,
+      headers: CORS_HEADERS_AUTH,
+    });
+  }
+
+  await serverDb.put(key, {
+    ...record,
+    status: "paid",
+    updatedAt: Date.now(),
+    raw: event,
+  } satisfies WaffoPaymentRecord);
+
+  const result = await rechargeUserBalance(
+    record.userId,
+    record.credits,
+    "waffo_pancake_recharge",
+    paymentRequestId
+  );
+  if (!result.success && result.error !== "Duplicate transaction") {
+    return new Response(result.error || "Recharge failed", {
+      status: 500,
+      headers: CORS_HEADERS_AUTH,
+    });
+  }
+
+  return new Response("OK", { status: 200, headers: CORS_HEADERS_AUTH });
+};
+
+export const waffoPaymentProvider: PaymentProvider = {
+  path: "waffo",
+  handleConfig: handleWaffoConfig,
+  handleCreateCheckout: handleCreateWaffoOrder,
+  handleWebhook: handleWaffoWebhook,
+};

package/server/preview/previewCapability.ts

@@ -0,0 +1,90 @@
+export type PreviewCapability =
+  | "core"
+  | "web-utility"
+  | "cloudflare"
+  | "app-api"
+  | "app-sandbox"
+  | "media"
+  | "agent-run"
+  | "machine-routes"
+  | "cli-chat"
+  | "memory"
+  | "email-inbound"
+  | "agent-email-registration"
+  | "waffo-payment"
+  | "database"
+  | "share"
+  | "sqlite"
+  | "realtime"
+  | "render";
+
+export function isRealtimeCapability(capability: PreviewCapability): boolean {
+  return capability === "realtime";
+}
+
+export function classifyHttpPreviewCapability(url: URL): PreviewCapability {
+  const { pathname } = url;
+
+  if (
+    pathname === "/api/fetch-webpage" ||
+    pathname === "/api/read-x-post" ||
+    pathname === "/api/apify-actor" ||
+    pathname === "/api/browser-tool" ||
+    pathname === "/api/exa-search"
+  ) {
+    return "web-utility";
+  }
+
+  if (
+    pathname.startsWith("/api/cloudflare-") ||
+    pathname.startsWith("/api/cf-")
+  ) {
+    return "cloudflare";
+  }
+
+  if (pathname === "/api/cli/chat") return "cli-chat";
+  if (pathname === "/api/agent/run") return "agent-run";
+
+  if (
+    pathname === "/api/events/:channel" ||
+    pathname.startsWith("/api/events/") ||
+    pathname === "/api/notifications"
+  ) {
+    return "realtime";
+  }
+
+  if (pathname === "/api/machines" || pathname.startsWith("/api/machines/")) {
+    return "machine-routes";
+  }
+
+  if (pathname.startsWith("/api/memory/")) return "memory";
+  if (pathname === "/api/email/inbound/cloudflare") return "email-inbound";
+  if (pathname.startsWith("/api/payments/waffo/")) return "waffo-payment";
+
+  if (
+    pathname.startsWith("/api/share/") ||
+    pathname.startsWith("/api/v1/share/")
+  ) {
+    return "share";
+  }
+
+  if (pathname.startsWith("/api/sqlite/")) return "sqlite";
+  if (pathname.startsWith("/api/app/")) return "app-api";
+  if (pathname === "/apps" || pathname.startsWith("/apps/")) {
+    return "app-sandbox";
+  }
+
+  if (
+    pathname === "/api/openai-image" ||
+    pathname === "/api/ocr" ||
+    pathname === "/api/whisper-v3"
+  ) {
+    return "media";
+  }
+
+  if (pathname.startsWith("/api/") || pathname.startsWith("/api/v1/db/")) {
+    return "database";
+  }
+
+  return "render";
+}

package/server/preview/previewConfig.ts

@@ -0,0 +1,54 @@
+import type { PreviewCapability } from "./previewCapability";
+
+type PreviewEnv = Partial<
+  Record<
+    | "PREVIEW_SLOT_SLUG"
+    | "PREVIEW_HOSTS"
+    | "PREVIEW_OWNED_CAPABILITIES"
+    | "PREVIEW_FALLBACK_ORIGIN",
+    string
+  >
+>;
+
+export type PreviewSlotConfig = {
+  slug: string;
+  hosts: string[];
+  ownedCapabilities: PreviewCapability[];
+  fallbackOrigin: string;
+};
+
+export type PreviewConfig =
+  | { enabled: false; slot: null }
+  | { enabled: true; slot: PreviewSlotConfig };
+
+function splitCsv(value?: string): string[] {
+  return [
+    ...new Set(
+      String(value || "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+    ),
+  ];
+}
+
+export function resolvePreviewConfig(env: PreviewEnv): PreviewConfig {
+  const slug = String(env.PREVIEW_SLOT_SLUG || "").trim();
+  const hosts = splitCsv(env.PREVIEW_HOSTS);
+  const ownedCapabilities = splitCsv(env.PREVIEW_OWNED_CAPABILITIES).sort() as PreviewCapability[];
+  const fallbackOrigin = String(env.PREVIEW_FALLBACK_ORIGIN || "").trim();
+
+  if (!slug || hosts.length === 0 || ownedCapabilities.length === 0 || !fallbackOrigin) {
+    return { enabled: false, slot: null };
+  }
+
+  return {
+    enabled: true,
+    slot: {
+      slug,
+      hosts,
+      ownedCapabilities,
+      fallbackOrigin,
+    },
+  };
+}

package/server/preview/previewGateway.ts

@@ -0,0 +1,71 @@
+import type { PreviewCapability } from "./previewCapability";
+
+type PreviewDecisionInput = {
+  previewEnabled: boolean;
+  requestHost: string;
+  capability: PreviewCapability;
+  previewHosts: string[];
+  ownedCapabilities: PreviewCapability[];
+};
+
+type ForwardInput = {
+  request: Request;
+  fallbackOrigin: string;
+  slotSlug: string;
+  capability: PreviewCapability;
+  fetchImpl?: typeof fetch;
+};
+
+export function buildPreviewRoutingDecision(input: PreviewDecisionInput) {
+  if (!input.previewEnabled) return { mode: "local" } as const;
+  if (!input.previewHosts.includes(input.requestHost)) {
+    return { mode: "local" } as const;
+  }
+  if (input.ownedCapabilities.includes(input.capability)) {
+    return { mode: "local" } as const;
+  }
+  return { mode: "fallback" } as const;
+}
+
+export function addPreviewSourceHeaders(
+  response: Response,
+  meta: {
+    slotSlug: string;
+    capability: PreviewCapability;
+    decision: "local" | "fallback";
+  }
+) {
+  const next = new Response(response.body, response);
+  next.headers.set("x-nolo-preview-slot", meta.slotSlug);
+  next.headers.set("x-nolo-preview-capability", meta.capability);
+  next.headers.set("x-nolo-preview-decision", meta.decision);
+  return next;
+}
+
+export async function forwardToPreviewFallback(
+  input: ForwardInput
+): Promise<Response> {
+  const url = new URL(input.request.url);
+  const target = new URL(`${url.pathname}${url.search}`, input.fallbackOrigin);
+  const headers = new Headers(input.request.headers);
+
+  headers.set("x-nolo-preview-slot", input.slotSlug);
+  headers.set("x-nolo-preview-capability", input.capability);
+  headers.set("x-nolo-preview-decision", "fallback");
+
+  const body =
+    input.request.method === "GET" || input.request.method === "HEAD"
+      ? undefined
+      : input.request.clone().body;
+
+  const fetchImpl = input.fetchImpl ?? fetch;
+
+  return fetchImpl(
+    new Request(target, {
+      method: input.request.method,
+      headers,
+      body,
+      duplex: body ? "half" : undefined,
+    } as RequestInit)
+  );
+}

package/server/preview/previewRealtime.ts

@@ -0,0 +1,33 @@
+import type { PreviewCapability } from "./previewCapability";
+import { buildPreviewRoutingDecision } from "./previewGateway";
+
+export type RealtimeTransport = "events" | "notifications" | "connector-ws";
+
+export function classifyRealtimeTransport(url: URL): RealtimeTransport | null {
+  if (url.pathname.startsWith("/api/events/")) return "events";
+  if (url.pathname === "/api/notifications") return "notifications";
+  if (url.pathname === "/api/connector/ws") return "connector-ws";
+  return null;
+}
+
+export function describeRealtimePreviewDecision(input: {
+  previewEnabled: boolean;
+  requestHost: string;
+  previewHosts: string[];
+  ownedCapabilities: PreviewCapability[];
+  transport: RealtimeTransport;
+}) {
+  const decision = buildPreviewRoutingDecision({
+    previewEnabled: input.previewEnabled,
+    requestHost: input.requestHost,
+    capability: "realtime",
+    previewHosts: input.previewHosts,
+    ownedCapabilities: input.ownedCapabilities,
+  });
+
+  return {
+    ...decision,
+    capability: "realtime" as const,
+    transport: input.transport,
+  };
+}