nolo-cli 0.1.26 → 0.1.29

package/server/handlers/connector/connectorWebSocket.ts

@@ -0,0 +1,117 @@
+import { authenticateRequest } from "../../../auth/utils";
+
+import { authenticateMachineToken } from "../machines/machineAuth";
+import {
+  type createConnectorConnectionRegistry,
+  connectorConnectionRegistry,
+} from "./connectorConnectionRegistry";
+
+type AuthResult = { userId: string } | Response;
+type ConnectorRegistry = ReturnType<typeof createConnectorConnectionRegistry>;
+
+type ConnectorWsData = {
+  connector?: {
+    ownerUserId: string;
+    machineId: string;
+    preview?: {
+      slotSlug: string;
+      capability: "realtime";
+      decision: "local" | "fallback";
+      transport: "connector-ws";
+      wsUrl: string;
+    } | null;
+    connection?: ReturnType<ConnectorRegistry["register"]>;
+  };
+};
+
+type BunServerLike = {
+  upgrade(req: Request, options: { data: ConnectorWsData }): boolean;
+};
+
+async function defaultAuthenticate(req: Request): Promise<AuthResult> {
+  const result = await authenticateRequest(req);
+  if (result instanceof Response) return result;
+  return { userId: result.userId };
+}
+
+export async function handleConnectorUpgradeRequest(
+  req: Request,
+  server: BunServerLike,
+  deps: {
+    authenticate?: (req: Request) => Promise<AuthResult>;
+    authenticateMachine?: typeof authenticateMachineToken;
+    preview?: ConnectorWsData["connector"]["preview"];
+  } = {}
+) {
+  const url = new URL(req.url);
+  const machineId = url.searchParams.get("machineId")?.trim();
+  if (!machineId) {
+    return new Response("machineId is required", { status: 400 });
+  }
+
+  const machineAuth = await (deps.authenticateMachine ?? authenticateMachineToken)(req);
+  if (machineAuth instanceof Response) return machineAuth;
+
+  const auth = machineAuth
+    ? { userId: machineAuth.userId }
+    : await (deps.authenticate ?? defaultAuthenticate)(req);
+  if (auth instanceof Response) return auth;
+
+  if (deps.preview?.decision === "fallback") {
+    return Response.json({
+      wsUrl: deps.preview.wsUrl,
+      slotSlug: deps.preview.slotSlug,
+      capability: deps.preview.capability,
+      decision: deps.preview.decision,
+      transport: deps.preview.transport,
+    });
+  }
+
+  const upgraded = server.upgrade(req, {
+    data: {
+      connector: {
+        ownerUserId: auth.userId,
+        machineId,
+        preview: deps.preview ?? null,
+      },
+    },
+  });
+  return upgraded ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
+}
+
+export function handleConnectorOpen(
+  ws: { data?: ConnectorWsData; send(message: string): unknown },
+  deps: { registry?: ConnectorRegistry } = {}
+) {
+  const connector = ws.data?.connector;
+  if (!connector) return false;
+  const registry = deps.registry ?? connectorConnectionRegistry;
+  connector.connection = registry.register({
+    ownerUserId: connector.ownerUserId,
+    machineId: connector.machineId,
+    send: (message) => ws.send(message),
+  });
+  return true;
+}
+
+export function handleConnectorMessage(
+  ws: { data?: ConnectorWsData },
+  message: string | Buffer
+) {
+  const connector = ws.data?.connector;
+  if (!connector?.connection) return false;
+  connector.connection.receive(String(message));
+  return true;
+}
+
+export function handleConnectorClose(
+  ws: { data?: ConnectorWsData },
+  deps: { registry?: ConnectorRegistry } = {}
+) {
+  const connector = ws.data?.connector;
+  if (!connector) return false;
+  const registry = deps.registry ?? connectorConnectionRegistry;
+  registry.unregister(connector.ownerUserId, connector.machineId);
+  connector.connection = undefined;
+  return true;
+}

package/server/handlers/creatorEarningsReportHandler.ts

@@ -0,0 +1,97 @@
+import { getBillingLedgerRuntime } from "../../auth/server/ledger";
+import type { CreatorEarningsReportStore } from "../../auth/server/creatorEarningsReport";
+import { buildCreatorEarningsReport } from "../../auth/server/creatorEarningsReport";
+
+const JSON_HEADERS = {
+  "content-type": "application/json; charset=utf-8",
+};
+
+type CreatorEarningsReportEnv = NodeJS.ProcessEnv & {
+  BILLING_LEDGER_AUDIT_SECRET?: string;
+  BILLING_LEDGER_CLUSTER_ID?: string;
+};
+
+const json = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+
+const parseOptionalTimestamp = (value: string | null) => {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) return Number(trimmed);
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`invalid timestamp: ${value}`);
+  }
+  return parsed;
+};
+
+const parseSinceHours = (value: string | null) => {
+  if (!value) return 24;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`invalid sinceHours: ${value}`);
+  }
+  return parsed;
+};
+
+const resolveDefaultStore = async (): Promise<CreatorEarningsReportStore> => {
+  const dbModule = await import("../../database/server/db");
+  return dbModule.default as CreatorEarningsReportStore;
+};
+
+export function createCreatorEarningsReportHandler({
+  store,
+  env = process.env,
+  nowMs,
+}: {
+  store?: CreatorEarningsReportStore;
+  env?: Partial<CreatorEarningsReportEnv>;
+  nowMs?: number;
+} = {}) {
+  return async function handleCreatorEarningsReport(req: Request) {
+    const expectedSecret = String(env.BILLING_LEDGER_AUDIT_SECRET || "").trim();
+    if (!expectedSecret) {
+      return new Response("Not Found", { status: 404 });
+    }
+
+    const providedSecret =
+      req.headers.get("x-billing-ledger-audit-secret")?.trim() || "";
+    if (providedSecret !== expectedSecret) {
+      return json({ success: false, error: "Unauthorized" }, 401);
+    }
+
+    try {
+      const url = new URL(req.url);
+      const now = nowMs ?? Date.now();
+      const untilMs = parseOptionalTimestamp(url.searchParams.get("until")) ?? now;
+      const explicitSince = parseOptionalTimestamp(url.searchParams.get("since"));
+      const sinceMs =
+        explicitSince ??
+        untilMs - parseSinceHours(url.searchParams.get("sinceHours")) * 3600_000;
+      const clusterId =
+        url.searchParams.get("cluster")?.trim() ||
+        getBillingLedgerRuntime({ ...process.env, ...env }).clusterId;
+
+      const report = await buildCreatorEarningsReport({
+        store: store ?? (await resolveDefaultStore()),
+        clusterId,
+        sinceMs,
+        untilMs,
+        nowMs: now,
+      });
+
+      return json({ success: true, report });
+    } catch (error) {
+      return json(
+        {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        400
+      );
+    }
+  };
+}
+
+export const handleCreatorEarningsReport = createCreatorEarningsReportHandler();

package/server/handlers/creatorSettlementReportHandler.ts

@@ -0,0 +1,98 @@
+import { getBillingLedgerRuntime } from "../../auth/server/ledger";
+import type { CreatorSettlementReportStore } from "../../auth/server/creatorSettlementReport";
+import { buildCreatorSettlementReport } from "../../auth/server/creatorSettlementReport";
+
+const JSON_HEADERS = {
+  "content-type": "application/json; charset=utf-8",
+};
+
+type CreatorSettlementReportEnv = NodeJS.ProcessEnv & {
+  BILLING_LEDGER_AUDIT_SECRET?: string;
+  BILLING_LEDGER_CLUSTER_ID?: string;
+};
+
+const json = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), { status, headers: JSON_HEADERS });
+
+const parseOptionalTimestamp = (value: string | null) => {
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (/^\d+$/.test(trimmed)) return Number(trimmed);
+  const parsed = Date.parse(trimmed);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`invalid timestamp: ${value}`);
+  }
+  return parsed;
+};
+
+const parseSinceHours = (value: string | null) => {
+  if (!value) return 24;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`invalid sinceHours: ${value}`);
+  }
+  return parsed;
+};
+
+const resolveDefaultStore = async (): Promise<CreatorSettlementReportStore> => {
+  const dbModule = await import("../../database/server/db");
+  return dbModule.default as CreatorSettlementReportStore;
+};
+
+export function createCreatorSettlementReportHandler({
+  store,
+  env = process.env,
+  nowMs,
+}: {
+  store?: CreatorSettlementReportStore;
+  env?: Partial<CreatorSettlementReportEnv>;
+  nowMs?: number;
+} = {}) {
+  return async function handleCreatorSettlementReport(req: Request) {
+    const expectedSecret = String(env.BILLING_LEDGER_AUDIT_SECRET || "").trim();
+    if (!expectedSecret) {
+      return new Response("Not Found", { status: 404 });
+    }
+
+    const providedSecret =
+      req.headers.get("x-billing-ledger-audit-secret")?.trim() || "";
+    if (providedSecret !== expectedSecret) {
+      return json({ success: false, error: "Unauthorized" }, 401);
+    }
+
+    try {
+      const url = new URL(req.url);
+      const now = nowMs ?? Date.now();
+      const untilMs = parseOptionalTimestamp(url.searchParams.get("until")) ?? now;
+      const explicitSince = parseOptionalTimestamp(url.searchParams.get("since"));
+      const sinceMs =
+        explicitSince ??
+        untilMs - parseSinceHours(url.searchParams.get("sinceHours")) * 3600_000;
+      const clusterId =
+        url.searchParams.get("cluster")?.trim() ||
+        getBillingLedgerRuntime({ ...process.env, ...env }).clusterId;
+
+      const report = await buildCreatorSettlementReport({
+        store: store ?? (await resolveDefaultStore()),
+        clusterId,
+        sinceMs,
+        untilMs,
+        nowMs: now,
+      });
+
+      return json({ success: true, report });
+    } catch (error) {
+      return json(
+        {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        400
+      );
+    }
+  };
+}
+
+export const handleCreatorSettlementReport =
+  createCreatorSettlementReportHandler();

package/server/handlers/deepseekOcrHandler.ts

@@ -0,0 +1,114 @@
+import { getFileContentById } from "../../database/server/fileService";
+import { authenticateRequest } from "../../auth/utils";
+import { chargeExternalTool } from "../../ai/token/externalToolCost";
+
+export const handleDeepseekOcr = async (req: Request): Promise<Response> => {
+    const DEEPINFRA_API_KEY = process.env.DEEPINFRA_API_KEY;
+
+    if (req.method === "OPTIONS") {
+        return new Response(null, {
+            status: 204,
+            headers: {
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Headers": "Content-Type, Authorization",
+            },
+        });
+    }
+
+    const auth = await authenticateRequest(req);
+    if (auth instanceof Response) return auth;
+
+    if (!DEEPINFRA_API_KEY) {
+        return new Response(JSON.stringify({ error: "Server missing DEEPINFRA_API_KEY environment variable" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+        });
+    }
+
+    try {
+        const body: any = await req.json();
+        const { imageUrl, prompt, dialogId } = body;
+
+        if (!imageUrl || typeof imageUrl !== "string") {
+            return new Response(JSON.stringify({ error: "缺少有效的 imageUrl 参数" }), {
+                status: 400,
+                headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
+            });
+        }
+
+        let finalImageUrl = imageUrl;
+
+        if (imageUrl && (imageUrl.startsWith("file-") || /^[0-9A-Z]{26}$/.test(imageUrl))) {
+            try {
+                const { buffer, metadata } = await getFileContentById(imageUrl);
+                const base64 = buffer.toString("base64");
+                finalImageUrl = `data:${metadata.mimeType || "image/png"};base64,${base64}`;
+            } catch (e: any) {
+                console.error(`Failed to resolve file content for ${imageUrl}:`, e);
+                if (imageUrl.startsWith("file-")) {
+                    return new Response(JSON.stringify({ error: `File not found or inaccessible: ${imageUrl}` }), {
+                        status: 404,
+                        headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+                    });
+                }
+            }
+        }
+
+        const response = await fetch("https://api.deepinfra.com/v1/openai/chat/completions", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${DEEPINFRA_API_KEY}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                model: "deepseek-ai/DeepSeek-OCR",
+                messages: [
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "text",
+                                text: prompt || "识别图片中的所有文字"
+                            },
+                            {
+                                type: "image_url",
+                                image_url: {
+                                    url: finalImageUrl
+                                }
+                            }
+                        ]
+                    }
+                ],
+            }),
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            return new Response(JSON.stringify({ error: `DeepInfra API error: ${errorText}` }), {
+                status: response.status,
+                headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+            });
+        }
+
+        const data = await response.json();
+        await chargeExternalTool({
+            userId: auth.userId,
+            toolId: "deepseek-ai/DeepSeek-OCR",
+            dialogId,
+            inputTokens: data.usage?.prompt_tokens ?? 0,
+            outputTokens: data.usage?.completion_tokens ?? 0,
+            reason: "deepseek_ocr",
+        });
+        return new Response(JSON.stringify(data), {
+            status: 200,
+            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+        });
+
+    } catch (error: any) {
+        console.error("DeepseekOCR handler error:", error);
+        return new Response(JSON.stringify({ error: error.message }), {
+            status: 500,
+            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" }
+        });
+    }
+};

package/server/handlers/deleteMemoryHandler.ts

@@ -0,0 +1,115 @@
+import { authenticateRequest, CORS_HEADERS_AUTH } from "../../auth/utils";
+import {
+  deleteMemoriesForOwner,
+} from "../../ai/memory/delete";
+import type {
+  MemoryFacet,
+  MemoryKind,
+  MemorySubjectType,
+} from "../../ai/memory/types";
+
+const json = (data: any, status = 200): Response =>
+  new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS_AUTH },
+  });
+
+const normalizeStringArray = (value: unknown): string[] | undefined => {
+  if (!Array.isArray(value)) return undefined;
+  const items = value
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return items.length > 0 ? items : undefined;
+};
+
+const normalizeKinds = (value: unknown): MemoryKind[] | undefined => {
+  const items = normalizeStringArray(value);
+  if (!items) return undefined;
+  const allowed = new Set<MemoryKind>(["episodic", "semantic", "procedural"]);
+  const filtered = items.filter((item): item is MemoryKind => allowed.has(item as MemoryKind));
+  return filtered.length > 0 ? filtered : undefined;
+};
+
+const normalizeFacets = (value: unknown): MemoryFacet[] | undefined => {
+  const items = normalizeStringArray(value);
+  if (!items) return undefined;
+  const allowed = new Set<MemoryFacet>([
+    "preference",
+    "tension",
+    "unfinished",
+    "goal",
+    "style",
+  ]);
+  const filtered = items.filter((item): item is MemoryFacet => allowed.has(item as MemoryFacet));
+  return filtered.length > 0 ? filtered : undefined;
+};
+
+const normalizeSubjectType = (value: unknown): MemorySubjectType | undefined => {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  if (!normalized) return undefined;
+  if (!["user", "agent", "space", "project", "system"].includes(normalized)) {
+    throw new Error(`unsupported subjectType: ${normalized}`);
+  }
+  return normalized as MemorySubjectType;
+};
+
+export async function handleDeleteMemory(req: Request): Promise<Response> {
+  if (req.method === "OPTIONS") {
+    return new Response(null, { status: 204, headers: CORS_HEADERS_AUTH });
+  }
+
+  const auth = await authenticateRequest(req);
+  if (auth instanceof Response) return auth;
+
+  let body: Record<string, unknown> = {};
+  try {
+    body = await req.json();
+  } catch {
+    return json(
+      { error: { code: "INVALID_JSON", message: "请求体必须是合法的 JSON" } },
+      400
+    );
+  }
+
+  try {
+    const result = await deleteMemoriesForOwner(
+      { ownerType: "user", ownerId: auth.userId },
+      {
+        ids: normalizeStringArray(body.ids),
+        kinds: normalizeKinds(body.kinds),
+        facets: normalizeFacets(body.facets),
+        subjectType: normalizeSubjectType(body.subjectType),
+        subjectId:
+          typeof body.subjectId === "string" ? body.subjectId.trim() || undefined : undefined,
+        patternKeyPrefix:
+          typeof body.patternKeyPrefix === "string"
+            ? body.patternKeyPrefix.trim() || undefined
+            : undefined,
+        sourceDialogId:
+          typeof body.sourceDialogId === "string"
+            ? body.sourceDialogId.trim() || undefined
+            : undefined,
+        tags: normalizeStringArray(body.tags),
+        limit:
+          typeof body.limit === "number" && Number.isFinite(body.limit)
+            ? body.limit
+            : undefined,
+      }
+    );
+
+    return json({
+      success: true,
+      deletedCount: result.deletedCount,
+      deletedIds: result.deletedIds,
+    });
+  } catch (error: any) {
+    const message =
+      typeof error?.message === "string" ? error.message : "Failed to delete memory";
+    return json(
+      { error: { code: "DELETE_MEMORY_FAILED", message } },
+      message.startsWith("unsupported") ? 400 : 500
+    );
+  }
+}