nolo-cli 0.1.31 → 0.1.32

package/server/handlers/desktopUpdaterHandler.ts

@@ -1,240 +0,0 @@
-import {
-  normalizeDesktopReleaseManifest,
-  type DesktopReleasePlatform,
-} from "../../app/constants/desktopReleaseManifest";
-import { createDesktopUpdaterSnapshot } from "../../desktop/desktopUpdaterState";
-import type { DesktopUpdaterReleaseArtifact } from "../../desktop/desktopUpdatePolicy";
-
-const JSON_HEADERS = {
-  "content-type": "application/json; charset=utf-8",
-};
-
-let activeOperation: "check" | "download" | "apply" | null = null;
-let activeTask: Promise<void> | null = null;
-const DESKTOP_MANIFEST_CACHE_TTL_MS = 30_000;
-const manifestCache = new Map<
-  string,
-  {
-    fetchedAt: number;
-    artifact: DesktopUpdaterReleaseArtifact | null;
-    error: string | 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");
-type DesktopRuntimeModule = Awaited<ReturnType<typeof loadDesktopRuntime>>;
-type UpdaterInstance = DesktopRuntimeModule["Updater"];
-
-const resolveDesktopReleasePlatform = (): DesktopReleasePlatform =>
-  process.platform === "win32"
-    ? "windows"
-    : process.platform === "darwin"
-      ? "macos"
-      : "linux";
-
-const resolveDesktopManifestUrl = (baseUrl: string) =>
-  `${baseUrl.replace(/\/+$/, "")}/desktop-release-manifest.json`;
-
-const latestStatus = (Updater: Awaited<ReturnType<typeof loadDesktopRuntime>>["Updater"]) => {
-  const history = Updater.getStatusHistory();
-  return history.length > 0 ? history[history.length - 1] : null;
-};
-
-const readPublishedReleaseArtifact = async (
-  baseUrl: string,
-  platform: DesktopReleasePlatform
-) => {
-  const cacheKey = `${platform}:${baseUrl.replace(/\/+$/, "")}`;
-  const cached = manifestCache.get(cacheKey);
-  if (cached && Date.now() - cached.fetchedAt < DESKTOP_MANIFEST_CACHE_TTL_MS) {
-    return cached;
-  }
-
-  try {
-    const response = await fetch(resolveDesktopManifestUrl(baseUrl), {
-      method: "GET",
-      headers: {
-        accept: "application/json",
-      },
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-
-    const manifest = normalizeDesktopReleaseManifest(await response.json());
-    if (!manifest) {
-      throw new Error("invalid manifest payload");
-    }
-
-    const artifact = manifest.artifacts[platform];
-    const result = {
-      fetchedAt: Date.now(),
-      artifact: artifact ? { platform, ...artifact } : null,
-      error: artifact ? null : `manifest is missing a ${platform} artifact`,
-    };
-    manifestCache.set(cacheKey, result);
-    return result;
-  } catch (error) {
-    const result = {
-      fetchedAt: Date.now(),
-      artifact: null,
-      error:
-        error instanceof Error ? error.message : "failed to fetch desktop release manifest",
-    };
-    manifestCache.set(cacheKey, result);
-    return result;
-  }
-};
-
-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(),
-  ]);
-  const platform = resolveDesktopReleasePlatform();
-  const updateInfo = Updater.updateInfo?.() ?? null;
-  const shouldLoadReleaseArtifact = Boolean(updateInfo?.updateAvailable || updateInfo?.updateReady);
-  const releaseArtifactState = shouldLoadReleaseArtifact
-    ? await readPublishedReleaseArtifact(baseUrl, platform)
-    : { artifact: null, error: null };
-
-  return createDesktopUpdaterSnapshot({
-    desktop: true,
-    platform,
-    activeOperation,
-    localInfo: {
-      version,
-      hash,
-      channel,
-      baseUrl,
-    },
-    buildConfig,
-    updateInfo,
-    latestStatus: latestStatus(Updater),
-    statusHistory: Updater.getStatusHistory(),
-    releaseArtifact: releaseArtifactState.artifact,
-    manifestError: releaseArtifactState.error,
-  });
-};
-
-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;
-};
-
-const OPERATION_EXECUTORS: Record<
-  "check" | "download" | "apply",
-  { resetHistory?: boolean; run: (updater: UpdaterInstance) => Promise<void> }
-> = {
-  check: {
-    resetHistory: true,
-    run: (updater) => updater.checkForUpdate(),
-  },
-  download: {
-    run: (updater) => updater.downloadUpdate(),
-  },
-  apply: {
-    run: (updater) => updater.applyUpdate(),
-  },
-};
-
-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" || action === "download" || action === "apply") {
-    const snapshot = await getUpdaterSnapshot();
-    if (action !== "check" && snapshot.summary.primaryAction !== action) {
-      return json(
-        {
-          error:
-            snapshot.summary.statusMessage ??
-            `Desktop updater is not ready to ${action} right now.`,
-        },
-        409
-      );
-    }
-
-    const operation = OPERATION_EXECUTORS[action];
-    const started = runOperation(
-      action,
-      async () => {
-        const { Updater } = await loadDesktopRuntime();
-        await operation.run(Updater);
-      },
-      operation.resetHistory ?? false
-    );
-    if (!started) {
-      return json(
-        {
-          error: `Desktop updater is already busy with ${activeOperation ?? "another operation"}.`,
-        },
-        409
-      );
-    }
-    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,
-        });
-    }
-};