nolo-cli 0.1.26 → 0.1.29

package/server/handlers/googleNativeChat.ts

@@ -0,0 +1,572 @@
+import { getModelConfig } from "../../ai/llm/providers";
+import type { Provider } from "../../ai/llm/providers";
+
+const GOOGLE_NATIVE_API_BASE =
+  "https://generativelanguage.googleapis.com/v1beta/models";
+
+type OpenAIImagePart = {
+  type: "image_url";
+  image_url?: { url?: string | null; detail?: "low" | "high" | "auto" };
+  google_native?: {
+    inlineData: {
+      mimeType: string;
+      data: string;
+    };
+    thoughtSignature?: string;
+  };
+};
+
+type OpenAITextPart = {
+  type: "text";
+  text?: string | null;
+};
+
+type OpenAIMessage = {
+  role?: string | null;
+  content?: string | Array<OpenAIImagePart | OpenAITextPart> | null;
+  name?: string | null;
+};
+
+type GeminiPart =
+  | { text: string }
+  | {
+      inlineData: { mimeType: string; data: string };
+      thoughtSignature?: string;
+    };
+
+type GeminiContent = {
+  role: "user" | "model";
+  parts: GeminiPart[];
+};
+
+type GeminiGenerateContentRequest = {
+  contents: GeminiContent[];
+  systemInstruction?: { parts: Array<{ text: string }> };
+  generationConfig?: Record<string, unknown>;
+};
+
+type ParsedGoogleNativeResponse = {
+  text: string;
+  images: Array<{
+    type: "image_url";
+    image_url: { url: string };
+    google_native: {
+      inlineData: {
+        mimeType: string;
+        data: string;
+      };
+      thoughtSignature?: string;
+    };
+  }>;
+  usage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  };
+  finishReason: string;
+  raw: Record<string, any>;
+};
+
+type GoogleNativeChatError = Error & {
+  status?: number;
+  responseText?: string;
+};
+
+const encoder = new TextEncoder();
+
+const createNativeChatError = (
+  message: string,
+  extras: Partial<GoogleNativeChatError> = {}
+): GoogleNativeChatError =>
+  Object.assign(new Error(message), extras);
+
+const isDataUrl = (value: string): boolean =>
+  typeof value === "string" && value.startsWith("data:");
+
+const isHttpUrl = (value: string): boolean => /^https?:\/\//i.test(value);
+
+const parseDataUrl = (
+  dataUrl: string
+): { mimeType: string; data: string } | null => {
+  const match = /^data:(.+?);base64,(.+)$/.exec(dataUrl);
+  if (!match) return null;
+  const [, mimeType, data] = match;
+  return { mimeType, data };
+};
+
+const normalizeImageUrlToInlineData = async (
+  rawUrl: string
+): Promise<{ mimeType: string; data: string }> => {
+  if (isDataUrl(rawUrl)) {
+    const parsed = parseDataUrl(rawUrl);
+    if (!parsed) {
+      throw createNativeChatError("Invalid data URL image content");
+    }
+    return parsed;
+  }
+
+  if (isHttpUrl(rawUrl)) {
+    const res = await fetch(rawUrl);
+    const responseText = res.ok ? "" : await res.text().catch(() => "");
+    if (!res.ok) {
+      throw createNativeChatError(
+        `Failed to fetch image URL: ${res.status} ${res.statusText}`,
+        { status: res.status, responseText }
+      );
+    }
+
+    const arrayBuffer = await res.arrayBuffer();
+    return {
+      mimeType: res.headers.get("content-type") || "image/png",
+      data: Buffer.from(arrayBuffer).toString("base64"),
+    };
+  }
+
+  return {
+    mimeType: "image/png",
+    data: rawUrl,
+  };
+};
+
+const normalizeMessageContentToGeminiParts = async (
+  content: OpenAIMessage["content"]
+): Promise<GeminiPart[]> => {
+  if (typeof content === "string") {
+    return content.trim() ? [{ text: content }] : [];
+  }
+
+  if (!Array.isArray(content)) return [];
+
+  const parts = await Promise.all(
+    content.map(async (part) => {
+      if (!part || typeof part !== "object") return null;
+
+      if (part.type === "text" && typeof part.text === "string") {
+        return part.text.trim() ? ({ text: part.text } as GeminiPart) : null;
+      }
+
+      if (
+        part.type === "image_url" &&
+        typeof part.image_url?.url === "string" &&
+        part.image_url.url.trim()
+      ) {
+        if (part.google_native?.inlineData?.data) {
+          return {
+            inlineData: part.google_native.inlineData,
+            ...(part.google_native.thoughtSignature
+              ? { thoughtSignature: part.google_native.thoughtSignature }
+              : {}),
+          } as GeminiPart;
+        }
+
+        const inlineData = await normalizeImageUrlToInlineData(
+          part.image_url.url.trim()
+        );
+        return { inlineData } as GeminiPart;
+      }
+
+      return null;
+    })
+  );
+
+  return parts.filter((part): part is GeminiPart => part !== null);
+};
+
+const normalizeRole = (role?: string | null): "system" | "user" | "assistant" => {
+  if (role === "assistant" || role === "model") return "assistant";
+  if (role === "system" || role === "developer") return "system";
+  return "user";
+};
+
+export const buildGoogleNativeImageRequest = async ({
+  messages,
+  imageConfig,
+  modalities,
+  maxTokens,
+}: {
+  messages: OpenAIMessage[];
+  imageConfig?: { aspect_ratio?: string; image_size?: string } | null;
+  modalities?: Array<"text" | "image"> | null;
+  maxTokens?: number;
+}): Promise<GeminiGenerateContentRequest> => {
+  const contents: GeminiContent[] = [];
+  const systemInstructionTexts: string[] = [];
+
+  for (const message of messages) {
+    const role = normalizeRole(message?.role);
+    const parts = await normalizeMessageContentToGeminiParts(message?.content);
+    if (parts.length === 0) continue;
+
+    if (role === "system") {
+      for (const part of parts) {
+        if ("text" in part && part.text.trim()) {
+          systemInstructionTexts.push(part.text);
+        }
+      }
+      continue;
+    }
+
+    contents.push({
+      role: role === "assistant" ? "model" : "user",
+      parts,
+    });
+  }
+
+  const generationConfig: Record<string, unknown> = {};
+  const responseModalities = modalities
+    ?.map((modality) => modality.toUpperCase())
+    .filter((value): value is "TEXT" | "IMAGE" => value === "TEXT" || value === "IMAGE");
+
+  if (responseModalities && responseModalities.length > 0) {
+    generationConfig.responseModalities = responseModalities;
+  }
+
+  if (imageConfig?.aspect_ratio || imageConfig?.image_size) {
+    generationConfig.imageConfig = {
+      ...(imageConfig.aspect_ratio
+        ? { aspectRatio: imageConfig.aspect_ratio }
+        : {}),
+      ...(imageConfig.image_size ? { imageSize: imageConfig.image_size } : {}),
+    };
+  }
+
+  if (typeof maxTokens === "number") {
+    generationConfig.maxOutputTokens = maxTokens;
+  }
+
+  return {
+    contents,
+    ...(systemInstructionTexts.length > 0
+      ? {
+          systemInstruction: {
+            parts: [{ text: systemInstructionTexts.join("\n\n") }],
+          },
+        }
+      : {}),
+    ...(Object.keys(generationConfig).length > 0 ? { generationConfig } : {}),
+  };
+};
+
+const parseGeminiInlineImages = (parts: any[]) =>
+  parts.flatMap((part) => {
+    const inline = part?.inlineData || part?.inline_data;
+    if (!inline?.data) return [];
+    const mimeType = inline.mimeType || inline.mime_type || "image/png";
+    return [
+      {
+        type: "image_url" as const,
+        image_url: {
+          url: `data:${mimeType};base64,${inline.data}`,
+        },
+        google_native: {
+          inlineData: {
+            mimeType,
+            data: inline.data,
+          },
+          ...(typeof part?.thoughtSignature === "string" && part.thoughtSignature
+            ? { thoughtSignature: part.thoughtSignature }
+            : {}),
+        },
+      },
+    ];
+  });
+
+const normalizeFinishReason = (finishReason: unknown): string => {
+  if (typeof finishReason !== "string" || !finishReason.trim()) return "stop";
+  const lowered = finishReason.toLowerCase();
+  if (lowered === "stop") return "stop";
+  if (lowered === "max_tokens") return "length";
+  return lowered;
+};
+
+export const parseGoogleNativeImageResponse = (
+  responseJson: Record<string, any>
+): ParsedGoogleNativeResponse => {
+  const candidate = responseJson?.candidates?.[0];
+  const parts = Array.isArray(candidate?.content?.parts)
+    ? candidate.content.parts
+    : [];
+
+  const text = parts
+    .map((part) => (typeof part?.text === "string" ? part.text : ""))
+    .filter(Boolean)
+    .join("\n");
+  const images = parseGeminiInlineImages(parts);
+
+  if (!text && images.length === 0) {
+    const blockReason =
+      responseJson?.promptFeedback?.blockReason ||
+      candidate?.finishReason ||
+      "empty_response";
+    throw createNativeChatError(`Google native image response was empty: ${blockReason}`);
+  }
+
+  const usageMetadata = responseJson?.usageMetadata || {};
+
+  return {
+    text,
+    images,
+    finishReason: normalizeFinishReason(candidate?.finishReason),
+    usage: {
+      prompt_tokens:
+        typeof usageMetadata.promptTokenCount === "number"
+          ? usageMetadata.promptTokenCount
+          : undefined,
+      completion_tokens:
+        typeof usageMetadata.candidatesTokenCount === "number"
+          ? usageMetadata.candidatesTokenCount
+          : undefined,
+      total_tokens:
+        typeof usageMetadata.totalTokenCount === "number"
+          ? usageMetadata.totalTokenCount
+          : undefined,
+    },
+    raw: responseJson,
+  };
+};
+
+const serializeSseChunk = (payload: Record<string, any>) =>
+  encoder.encode(`data: ${JSON.stringify(payload)}\n\n`);
+
+const buildAssistantContent = (
+  parsed: ParsedGoogleNativeResponse
+):
+  | string
+  | Array<
+      | { type: "text"; text: string }
+      | { type: "image_url"; image_url: { url: string } }
+    > => {
+  if (parsed.images.length === 0) {
+    return parsed.text;
+  }
+
+  const content: Array<
+    | { type: "text"; text: string }
+    | { type: "image_url"; image_url: { url: string } }
+  > = [];
+
+  if (parsed.text) {
+    content.push({ type: "text", text: parsed.text });
+  }
+  content.push(...parsed.images);
+  return content;
+};
+
+export const buildGoogleNativeCompletionPayload = ({
+  model,
+  parsed,
+}: {
+  model: string;
+  parsed: ParsedGoogleNativeResponse;
+}) => {
+  const created = Math.floor(Date.now() / 1000);
+
+  return {
+    id: `chatcmpl-google-${Date.now()}`,
+    object: "chat.completion",
+    created,
+    model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: buildAssistantContent(parsed),
+        },
+        finish_reason: parsed.finishReason,
+      },
+    ],
+    ...(parsed.usage ? { usage: parsed.usage } : {}),
+  };
+};
+
+export const buildGoogleNativeSseResponse = ({
+  model,
+  parsed,
+  streamHeaders,
+}: {
+  model: string;
+  parsed: ParsedGoogleNativeResponse;
+  streamHeaders: Record<string, string>;
+}): Response => {
+  const created = Math.floor(Date.now() / 1000);
+
+  return new Response(
+    new ReadableStream({
+      start(controller) {
+        controller.enqueue(
+          serializeSseChunk({
+            id: `chatcmpl-google-${Date.now()}`,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [
+              {
+                index: 0,
+                delta: {
+                  role: "assistant",
+                  ...(parsed.text ? { content: parsed.text } : {}),
+                  ...(parsed.images.length > 0 ? { images: parsed.images } : {}),
+                },
+                finish_reason: null,
+              },
+            ],
+          })
+        );
+
+        controller.enqueue(
+          serializeSseChunk({
+            id: `chatcmpl-google-${Date.now()}-done`,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            ...(parsed.usage ? { usage: parsed.usage } : {}),
+            choices: [
+              {
+                index: 0,
+                delta: {},
+                finish_reason: parsed.finishReason,
+              },
+            ],
+          })
+        );
+
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+        controller.close();
+      },
+    }),
+    {
+      status: 200,
+      headers: streamHeaders,
+    }
+  );
+};
+
+export const isGoogleNativeImageModel = (modelName?: string | null): boolean => {
+  const normalized = typeof modelName === "string" ? modelName.trim() : "";
+  if (!normalized) return false;
+
+  try {
+    const config = getModelConfig("google" as Provider, normalized);
+    return !!(config.hasImageOutput || config.supportsImageOutput);
+  } catch {
+    return false;
+  }
+};
+
+export async function requestGoogleNativeImageChat({
+  model,
+  body,
+  apiKey,
+  signal,
+}: {
+  model: string;
+  body: Record<string, any>;
+  apiKey: string;
+  signal?: AbortSignal;
+}): Promise<ParsedGoogleNativeResponse> {
+  const requestBody = await buildGoogleNativeImageRequest({
+    messages: Array.isArray(body.messages) ? body.messages : [],
+    imageConfig: body.image_config ?? null,
+    modalities: Array.isArray(body.modalities) ? body.modalities : null,
+    maxTokens: typeof body.max_tokens === "number" ? body.max_tokens : undefined,
+  });
+
+  const url = `${GOOGLE_NATIVE_API_BASE}/${encodeURIComponent(
+    model
+  )}:generateContent?key=${apiKey}`;
+
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(requestBody),
+    signal,
+  });
+
+  const rawText = await res.text().catch(() => "");
+  if (!res.ok) {
+    throw createNativeChatError(
+      `Google native image request failed: ${res.status} ${res.statusText}`,
+      {
+        status: res.status,
+        responseText: rawText,
+      }
+    );
+  }
+
+  let responseJson: Record<string, any>;
+  try {
+    responseJson = rawText ? JSON.parse(rawText) : {};
+  } catch (error) {
+    throw createNativeChatError(
+      `Google native image response JSON parse failed: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+      { responseText: rawText }
+    );
+  }
+
+  return parseGoogleNativeImageResponse(responseJson);
+}
+
+export async function fetchGoogleNativeImageChat({
+  model,
+  body,
+  apiKey,
+  signal,
+  streamHeaders,
+}: {
+  model: string;
+  body: Record<string, any>;
+  apiKey: string;
+  signal?: AbortSignal;
+  streamHeaders: Record<string, string>;
+}): Promise<Response> {
+  const parsed = await requestGoogleNativeImageChat({
+    model,
+    body,
+    apiKey,
+    signal,
+  });
+  return buildGoogleNativeSseResponse({
+    model,
+    parsed,
+    streamHeaders,
+  });
+}
+
+export async function fetchGoogleNativeImageCompletion({
+  model,
+  body,
+  apiKey,
+  signal,
+}: {
+  model: string;
+  body: Record<string, any>;
+  apiKey: string;
+  signal?: AbortSignal;
+}): Promise<Response> {
+  const parsed = await requestGoogleNativeImageChat({
+    model,
+    body,
+    apiKey,
+    signal,
+  });
+
+  return new Response(
+    JSON.stringify(
+      buildGoogleNativeCompletionPayload({
+        model,
+        parsed,
+      })
+    ),
+    {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+      },
+    }
+  );
+}

package/server/handlers/listFilesHandler.ts

@@ -0,0 +1,139 @@
+// 文件路径: packages/server/handlers/listFilesHandler.ts
+
+import { readdirSync, statSync } from "node:fs";
+import { resolve, relative, join, sep } from "node:path";
+
+type ListFilesRequestBody = {
+    path?: string;
+    maxFiles?: number;
+    ignore?: string[];
+};
+
+const JSON_HEADERS = { "Content-Type": "application/json; charset=utf-8" };
+const ROOT = process.cwd();
+
+// 默认忽略列表
+const DEFAULT_IGNORE = ["node_modules", ".git", "dist", "build", ".next", ".gemini"];
+
+function resolvePathUnderRoot(pathScope: string): string {
+    const absPath = resolve(ROOT, pathScope || ".");
+    const normalizedRoot = ROOT.endsWith(sep) ? ROOT : `${ROOT}${sep}`;
+    if (!absPath.startsWith(normalizedRoot) && absPath !== ROOT) {
+        throw new Error("path 必须位于项目根目录内");
+    }
+    return absPath;
+}
+
+function parseMaxFiles(value: unknown): number {
+    if (value === undefined || value === null) return 300;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error("maxFiles 必须是正整数");
+    }
+    return Math.min(value, 2000);
+}
+
+export async function handleListFiles(req: Request): Promise<Response> {
+    try {
+        if (req.method !== "POST") {
+            return new Response(JSON.stringify({ error: "Method not allowed" }), {
+                status: 405,
+                headers: { ...JSON_HEADERS, "Allow": "POST, OPTIONS" },
+            });
+        }
+
+        let body: unknown;
+        try {
+            body = await req.json();
+        } catch {
+            body = {}; // 允许空 body
+        }
+
+        const { path = ".", maxFiles, ignore = [] }: Partial<ListFilesRequestBody> =
+            typeof body === "object" && body !== null ? (body as any) : {};
+
+        if (typeof path !== "string") {
+            return new Response(JSON.stringify({ error: "path 必须是字符串" }), { status: 400, headers: JSON_HEADERS });
+        }
+
+        if (!Array.isArray(ignore) || !ignore.every((i) => typeof i === "string")) {
+            return new Response(JSON.stringify({ error: "ignore 必须是字符串数组" }), { status: 400, headers: JSON_HEADERS });
+        }
+
+        let safeMaxFiles = 300;
+        try {
+            safeMaxFiles = parseMaxFiles(maxFiles);
+        } catch (e: any) {
+            return new Response(JSON.stringify({ error: e?.message || "maxFiles 参数无效" }), { status: 400, headers: JSON_HEADERS });
+        }
+
+        let absRoot: string;
+        try {
+            absRoot = resolvePathUnderRoot(path);
+        } catch (e: any) {
+            return new Response(JSON.stringify({ error: e?.message || "path 参数无效" }), { status: 400, headers: JSON_HEADERS });
+        }
+
+        const ignoreList = [...DEFAULT_IGNORE, ...ignore];
+
+        const files: any[] = [];
+        let totalFiles = 0;
+        let truncated = false;
+
+        function walk(currentDir: string) {
+            if (files.length >= safeMaxFiles) {
+                truncated = true;
+                return;
+            }
+
+            let entries;
+            try {
+                entries = readdirSync(currentDir);
+            } catch (e) {
+                return; // 无法读取则跳过
+            }
+
+            for (const entry of entries) {
+                if (ignoreList.some(i => dMatch(entry, i))) continue;
+
+                const fullPath = join(currentDir, entry);
+                let stats;
+                try {
+                    stats = statSync(fullPath);
+                } catch {
+                    continue;
+                }
+
+                const relPath = relative(ROOT, fullPath);
+                totalFiles++;
+
+                if (stats.isDirectory()) {
+                    files.push({ path: relPath, type: "dir" });
+                    walk(fullPath);
+                } else {
+                    files.push({ path: relPath, type: "file", size: stats.size });
+                }
+
+                if (files.length >= safeMaxFiles) {
+                    truncated = true;
+                    return;
+                }
+            }
+        }
+
+        function dMatch(name: string, pattern: string) {
+            return name === pattern || name.includes(pattern);
+        }
+
+        walk(absRoot);
+
+        return new Response(JSON.stringify({
+            ok: true,
+            files,
+            totalFiles,
+            truncated
+        }), { status: 200, headers: JSON_HEADERS });
+
+    } catch (error: any) {
+        return new Response(JSON.stringify({ error: `listFiles 失败：${error.message}` }), { status: 500, headers: JSON_HEADERS });
+    }
+}