nolo-cli 0.1.30 → 0.1.32

package/server/handlers/desktopLocalConnectorHandler.ts

@@ -1,101 +0,0 @@
-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

@@ -1,132 +0,0 @@
-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

@@ -1,10 +0,0 @@
-// 向后兼容的薄包装层，真正逻辑已迁移至 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

@@ -1,65 +0,0 @@
-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

@@ -1,160 +0,0 @@
-// 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

@@ -1,73 +0,0 @@
-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,
-        });
-    }
-};