nolo-cli 0.1.26 → 0.1.29

package/server/handlers/desktopLocalConnectorHandler.ts

@@ -0,0 +1,101 @@
+import { runConnectorDaemon } from "../../connector-experimental/daemonLauncher";
+
+type StartDeps = {
+  runConnect?: typeof runConnectorDaemon;
+};
+
+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",
+};
+
+let lastStartedKey = "";
+
+function normalizeServerUrl(value: unknown) {
+  return typeof value === "string" ? value.trim().replace(/\/+$/, "") : "";
+}
+
+function isLocalDesktopRuntime() {
+  return process.env.NOLO_DESKTOP === "1";
+}
+
+export async function handleDesktopLocalConnectorStart(
+  req: Request,
+  deps: StartDeps = {}
+) {
+  if (!isLocalDesktopRuntime()) {
+    return new Response(JSON.stringify({ error: "Desktop runtime only" }), {
+      status: 404,
+      headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+    });
+  }
+  if (req.method === "OPTIONS") {
+    return new Response(null, { status: 204, headers: CORS_HEADERS });
+  }
+  if (req.method !== "POST") {
+    return new Response(JSON.stringify({ error: "Method not allowed" }), {
+      status: 405,
+      headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+    });
+  }
+
+  const body = await req.json().catch(() => ({})) as {
+    serverUrl?: unknown;
+    authToken?: unknown;
+  };
+  const serverUrl = normalizeServerUrl(body.serverUrl);
+  const authToken = typeof body.authToken === "string" ? body.authToken.trim() : "";
+  if (!serverUrl || !authToken) {
+    return new Response(JSON.stringify({ error: "serverUrl and authToken are required" }), {
+      status: 400,
+      headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+    });
+  }
+
+  const startKey = `${serverUrl}:${authToken.slice(-16)}`;
+  if (startKey === lastStartedKey) {
+    return new Response(JSON.stringify({ ok: true, started: false, reason: "already-started" }), {
+      status: 200,
+      headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+    });
+  }
+
+  const chunks: string[] = [];
+  const exitCode = await (deps.runConnect ?? runConnectorDaemon)({
+    env: {
+      ...process.env,
+      NOLO_SERVER: serverUrl,
+      AUTH_TOKEN: authToken,
+    },
+    output: {
+      write(chunk) {
+        chunks.push(chunk);
+      },
+    },
+  });
+
+  if (exitCode !== 0) {
+    return new Response(JSON.stringify({
+      ok: false,
+      error: chunks.join("").trim() || `Connector start failed with exit code ${exitCode}`,
+    }), {
+      status: 500,
+      headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+    });
+  }
+
+  lastStartedKey = startKey;
+  return new Response(JSON.stringify({
+    ok: true,
+    started: true,
+  }), {
+    status: 200,
+    headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+  });
+}
+
+export function __resetDesktopLocalConnectorStartForTest() {
+  lastStartedKey = "";
+}

package/server/handlers/desktopUpdaterHandler.ts

@@ -0,0 +1,132 @@
+const JSON_HEADERS = {
+  "content-type": "application/json; charset=utf-8",
+};
+
+let activeOperation: "check" | "download" | "apply" | null = null;
+let activeTask: Promise<void> | null = null;
+
+const isDesktopMode = () => process.env.NOLO_DESKTOP === "1";
+
+const json = (data: unknown, status = 200) =>
+  new Response(JSON.stringify(data), {
+    status,
+    headers: JSON_HEADERS,
+  });
+
+const notDesktopResponse = () =>
+  json({ error: "Desktop updater is only available inside Nolo Desktop." }, 404);
+
+const loadDesktopRuntime = async () => import("electrobun/bun");
+
+const latestStatus = (Updater: Awaited<ReturnType<typeof loadDesktopRuntime>>["Updater"]) => {
+  const history = Updater.getStatusHistory();
+  return history.length > 0 ? history[history.length - 1] : null;
+};
+
+const getUpdaterSnapshot = async () => {
+  const { BuildConfig, Updater } = await loadDesktopRuntime();
+  const [buildConfig, version, hash, channel, baseUrl] = await Promise.all([
+    BuildConfig.get().catch(() => null),
+    Updater.localInfo.version(),
+    Updater.localInfo.hash(),
+    Updater.localInfo.channel(),
+    Updater.localInfo.baseUrl(),
+  ]);
+
+  return {
+    desktop: true,
+    activeOperation,
+    localInfo: {
+      version,
+      hash,
+      channel,
+      baseUrl,
+    },
+    buildConfig,
+    updateInfo: Updater.updateInfo?.() ?? null,
+    latestStatus: latestStatus(Updater),
+    statusHistory: Updater.getStatusHistory(),
+  };
+};
+
+const runOperation = (
+  operation: "check" | "download" | "apply",
+  executor: () => Promise<void>,
+  resetHistory = false
+) => {
+  if (activeTask) {
+    return false;
+  }
+
+  activeOperation = operation;
+  activeTask = (async () => {
+    try {
+      if (resetHistory) {
+        const { Updater } = await loadDesktopRuntime();
+        Updater.clearStatusHistory();
+      }
+      await executor();
+    } finally {
+      activeOperation = null;
+      activeTask = null;
+    }
+  })();
+
+  activeTask.catch((error) => {
+    console.error(`[desktop-updater] ${operation} failed`, error);
+  });
+
+  return true;
+};
+
+export const handleDesktopUpdaterGet = async () => {
+  if (!isDesktopMode()) return notDesktopResponse();
+
+  try {
+    return json(await getUpdaterSnapshot());
+  } catch (error) {
+    return json(
+      { error: error instanceof Error ? error.message : "Failed to read updater state" },
+      500
+    );
+  }
+};
+
+export const handleDesktopUpdaterPost = async (req: Request) => {
+  if (!isDesktopMode()) return notDesktopResponse();
+
+  let body: { action?: string } = {};
+  try {
+    body = await req.json();
+  } catch {
+    return json({ error: "Invalid JSON body" }, 400);
+  }
+
+  const action = body.action;
+
+  if (action === "check") {
+    runOperation("check", async () => {
+      const { Updater } = await loadDesktopRuntime();
+      await Updater.checkForUpdate();
+    }, true);
+    return json(await getUpdaterSnapshot(), 202);
+  }
+
+  if (action === "download") {
+    runOperation("download", async () => {
+      const { Updater } = await loadDesktopRuntime();
+      await Updater.downloadUpdate();
+    });
+    return json(await getUpdaterSnapshot(), 202);
+  }
+
+  if (action === "apply") {
+    runOperation("apply", async () => {
+      const { Updater } = await loadDesktopRuntime();
+      await Updater.applyUpdate();
+    });
+    return json(await getUpdaterSnapshot(), 202);
+  }
+
+  return json({ error: "Unsupported action" }, 400);
+};

package/server/handlers/dialogEvents.ts

@@ -0,0 +1,10 @@
+// 向后兼容的薄包装层，真正逻辑已迁移至 eventBus.ts
+export { handleEvents as handleDialogEvents } from "./eventBus";
+import { pushEvent } from "./eventBus";
+import type { ServerEvent } from "./eventBus";
+
+export type DialogEvent = ServerEvent;
+
+export async function pushDialogEvent(dialogId: string, event: ServerEvent): Promise<void> {
+    return pushEvent(`dialog-${dialogId}`, event);
+}

package/server/handlers/emailInboundHandler.ts

@@ -0,0 +1,65 @@
+import type { ApiError } from "../api/types";
+import { receiveInboundEmail } from "../../database/server/emailRepository";
+import { getEmailProvider } from "../email/providerRegistry";
+
+const CORS_HEADERS: Record<string, string> = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, x-email-webhook-secret",
+};
+
+const json = (body: unknown, status = 200) =>
+  new Response(JSON.stringify(body), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      ...CORS_HEADERS,
+    },
+  });
+
+const errorStatus = (error: ApiError) =>
+  error.code === "unauthorized"
+    ? 401
+    : error.code === "forbidden"
+      ? 403
+      : error.code === "not_found"
+        ? 404
+        : error.code === "invalid_input"
+          ? 400
+          : 500;
+
+export async function handleCloudflareInboundEmail(req: Request) {
+  if (req.method === "OPTIONS") {
+    return new Response(null, { status: 204, headers: CORS_HEADERS });
+  }
+  if (req.method !== "POST") {
+    return json({ code: "invalid_input", message: "Method not allowed" }, 405);
+  }
+
+  const provider = getEmailProvider();
+  const verified = await provider.verifyWebhook(req);
+  if (!verified) {
+    return json({ code: "unauthorized", message: "Invalid email webhook secret" }, 401);
+  }
+
+  let payload: unknown;
+  try {
+    payload = await req.json();
+  } catch {
+    return json({ code: "invalid_input", message: "Invalid JSON body" }, 400);
+  }
+
+  try {
+    const result = await receiveInboundEmail(payload, provider);
+    return json({
+      success: true,
+      records: result.records,
+      existing: result.existing,
+    });
+  } catch (error: any) {
+    const apiError: ApiError = error?.code
+      ? error
+      : { code: "internal", message: error?.message || String(error) };
+    return json(apiError, errorStatus(apiError));
+  }
+}

package/server/handlers/eventBus.ts

@@ -0,0 +1,160 @@
+// packages/server/handlers/eventBus.ts
+// 通用 SSE pub/sub 总线
+// channel 命名约定：
+//   dialog-{dialogId}  → agent 后台任务状态
+//   space-{spaceId}    → space 内容变更广播
+//   user-{userId}      → 个人通知
+
+import { authenticateRequest } from "../../auth/utils";
+
+export type ServerEvent = Record<string, unknown> & { type: string };
+type EventChannelAuthorizer = (args: {
+    userId: string;
+    channel: string;
+}) => Promise<boolean> | boolean;
+
+const CORS: Record<string, string> = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization",
+};
+
+const encoder = new TextEncoder();
+const subscribers = new Map<string, Set<ReadableStreamDefaultController<Uint8Array>>>();
+const latestEvent = new Map<string, ServerEvent>();
+const channelAuthorizers = new Map<string, EventChannelAuthorizer>();
+
+// /api/events/{channel}  — channel 可以是任意不含斜杠的字符串
+function extractChannel(pathname: string): string | null {
+    const m = pathname.match(/^\/api\/events\/([^/]+)$/);
+    return m?.[1] ? decodeURIComponent(m[1]) : null;
+}
+
+function buildSseData(event: ServerEvent): string {
+    return `data: ${JSON.stringify(event)}\n\n`;
+}
+
+export function registerEventChannelAuthorizer(
+    prefix: string,
+    authorizer: EventChannelAuthorizer
+): void {
+    channelAuthorizers.set(prefix, authorizer);
+}
+
+async function canAccessChannel(userId: string, channel: string): Promise<boolean> {
+    const matchingPrefixes = [...channelAuthorizers.keys()]
+        .filter((prefix) => channel.startsWith(prefix))
+        .sort((a, b) => b.length - a.length);
+    for (const prefix of matchingPrefixes) {
+        const authorizer = channelAuthorizers.get(prefix);
+        if (!authorizer) continue;
+        return await authorizer({ userId, channel });
+    }
+    return true;
+}
+
+/** 向指定 channel 的所有订阅者广播一条事件 */
+export function pushEvent(channel: string, event: ServerEvent): void {
+    latestEvent.set(channel, event);
+    const set = subscribers.get(channel);
+    if (!set || set.size === 0) return;
+    const payload = encoder.encode(buildSseData(event));
+    for (const ctrl of set) {
+        try { ctrl.enqueue(payload); } catch { set.delete(ctrl); }
+    }
+}
+
+/** GET /api/events/:channel — SSE 订阅端点 */
+export async function handleEvents(req: Request): Promise<Response> {
+    if (req.method === "OPTIONS") {
+        return new Response(null, { status: 204, headers: CORS });
+    }
+
+    if (req.method !== "GET") {
+        return new Response(JSON.stringify({ error: "Method not allowed" }), {
+            status: 405,
+            headers: { ...CORS, "Content-Type": "application/json" },
+        });
+    }
+
+    const auth = await authenticateRequest(req);
+    if (auth instanceof Response) return auth;
+
+    const channel = extractChannel(new URL(req.url).pathname);
+    if (!channel) {
+        return new Response(JSON.stringify({ error: "Invalid events path" }), {
+            status: 404,
+            headers: { ...CORS, "Content-Type": "application/json" },
+        });
+    }
+
+    const allowed = await canAccessChannel(auth.userId, channel);
+    if (!allowed) {
+        return new Response(JSON.stringify({ error: "Forbidden" }), {
+            status: 403,
+            headers: { ...CORS, "Content-Type": "application/json" },
+        });
+    }
+
+    console.log(`[SSE] new connection: ${channel}`);
+
+    let controller: ReadableStreamDefaultController<Uint8Array>;
+    let heartbeat: ReturnType<typeof setInterval>;
+    let mySet: Set<ReadableStreamDefaultController<Uint8Array>>;
+    let cleaned = false;
+
+    const cleanup = (reason: string) => {
+        if (cleaned) return;
+        cleaned = true;
+        clearInterval(heartbeat);
+        mySet?.delete(controller);
+        if (mySet?.size === 0) subscribers.delete(channel);
+        console.log(`[SSE] cleanup: ${channel} reason=${reason}`);
+    };
+
+    const stream = new ReadableStream<Uint8Array>({
+        start(c) {
+            controller = c;
+
+            const enqueue = (text: string) => {
+                try { c.enqueue(encoder.encode(text)); } catch { /* client gone */ }
+            };
+
+            enqueue("retry: 1000\n");
+            enqueue(": connected\n\n");
+
+            // 补发最近一条事件，避免订阅竞态丢事件
+            const last = latestEvent.get(channel);
+            if (last) enqueue(buildSseData(last));
+
+            // 在 start() 内部获取/创建 set，避免并发 race condition
+            mySet = subscribers.get(channel) ?? new Set();
+            mySet.add(c);
+            subscribers.set(channel, mySet);
+
+            heartbeat = setInterval(() => {
+                if (cleaned) { clearInterval(heartbeat); return; }
+                enqueue(": ping\n\n");
+            }, 15000);
+        },
+        cancel() {
+            cleanup("stream_cancel");
+        },
+    });
+
+    req.signal.addEventListener("abort", () => {
+        cleanup("req_abort");
+        try { controller?.close(); } catch { /* already closed */ }
+    });
+
+    return new Response(stream, {
+        status: 200,
+        headers: {
+            ...CORS,
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache, no-transform",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no",
+        },
+    });
+}

package/server/handlers/exaSearchHandler.ts

@@ -0,0 +1,73 @@
+import { authenticateRequest, CORS_HEADERS_AUTH } from "../../auth/utils";
+import { chargeExternalTool } from "../../ai/token/externalToolCost";
+
+const JSON_HEADERS = { "Content-Type": "application/json", ...CORS_HEADERS_AUTH };
+
+export const handleExaSearch = async (req: Request): Promise<Response> => {
+    const EXA_API_KEY = process.env.EXA_API_KEY;
+
+    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;
+
+    if (!EXA_API_KEY) {
+        return new Response(JSON.stringify({ error: "Server missing EXA_API_KEY" }), {
+            status: 500,
+            headers: JSON_HEADERS,
+        });
+    }
+
+    try {
+        const body: any = await req.json();
+        const { query, numResults, useAutoprompt, type, contents, dialogId } = body;
+
+        if (!query || typeof query !== "string" || !query.trim()) {
+            return new Response(JSON.stringify({ error: "缺少有效的 query 参数" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        const response = await fetch("https://api.exa.ai/search", {
+            method: "POST",
+            headers: {
+                "x-api-key": EXA_API_KEY,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                query,
+                numResults,
+                useAutoprompt,
+                type,
+                contents,
+            }),
+        });
+
+        if (!response.ok) {
+            const errorText = await response.text();
+            return new Response(JSON.stringify({ error: `Exa API error: ${errorText}` }), {
+                status: response.status,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        const data = await response.json();
+        await chargeExternalTool({
+            userId: auth.userId,
+            toolId: "exa_search",
+            dialogId,
+            reason: "exa_search",
+        });
+        return new Response(JSON.stringify(data), { status: 200, headers: JSON_HEADERS });
+
+    } catch (error: any) {
+        console.error("Exa handler error:", error);
+        return new Response(JSON.stringify({ error: error.message }), {
+            status: 500,
+            headers: JSON_HEADERS,
+        });
+    }
+};