nolo-cli 0.1.39 → 0.1.41

package/app/utils/desktopAgentRuntimeTurnClient.ts

@@ -0,0 +1,73 @@
+import type {
+  AgentRuntimeMessageContent,
+  LocalAgentTurnResult,
+} from "../../agent-runtime";
+
+export type DesktopAgentRuntimeTurnResult =
+  | {
+      ok: true;
+      result: LocalAgentTurnResult;
+    }
+  | {
+      ok: false;
+      error: string;
+    };
+
+type RunDesktopAgentRuntimeTurnArgs = {
+  agentRef: string;
+  input: AgentRuntimeMessageContent;
+  continueDialogId?: string;
+  cwd?: string;
+  fetchImpl?: typeof fetch;
+};
+
+function buildDesktopAgentRuntimeTurnBody(args: RunDesktopAgentRuntimeTurnArgs) {
+  const continueDialogId =
+    typeof args.continueDialogId === "string"
+      ? args.continueDialogId.trim()
+      : "";
+
+  return {
+    agentRef: args.agentRef,
+    input: args.input,
+    ...(continueDialogId ? { continueDialogId } : {}),
+    ...(args.cwd ? { cwd: args.cwd } : {}),
+  };
+}
+
+function normalizeDesktopAgentRuntimeTurnError(data: any) {
+  return typeof data?.error === "string"
+    ? data.error
+    : "Failed to run desktop agent runtime turn";
+}
+
+export async function runDesktopAgentRuntimeTurn({
+  fetchImpl = fetch,
+  ...args
+}: RunDesktopAgentRuntimeTurnArgs): Promise<DesktopAgentRuntimeTurnResult> {
+  try {
+    const response = await fetchImpl("/api/desktop/agent-runtime/turn", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(buildDesktopAgentRuntimeTurnBody(args)),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok || data?.ok === false) {
+      return {
+        ok: false,
+        error: normalizeDesktopAgentRuntimeTurnError(data),
+      };
+    }
+    return {
+      ok: true,
+      result: data.result as LocalAgentTurnResult,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error
+        ? error.message
+        : "Failed to run desktop agent runtime turn",
+    };
+  }
+}

package/app/utils/env.ts

@@ -0,0 +1,17 @@
+//  app/utils/fileUtils.ts
+export const isBrowser = typeof window !== "undefined";
+const processEnv = typeof process !== "undefined" ? process.env : undefined;
+const reactNativeDev =
+  typeof globalThis !== "undefined" && "__DEV__" in globalThis
+    ? (globalThis as typeof globalThis & { __DEV__?: boolean }).__DEV__
+    : undefined;
+
+export const isProduction =
+  processEnv?.NOLO_FORCE_PRODUCTION === "1" ||
+  processEnv?.NODE_ENV === "production" ||
+  reactNativeDev === false;
+export const isDevelopment = !isProduction;
+export const getIsDesktopApp = (): boolean =>
+  (typeof process !== "undefined" ? process.env?.NOLO_DESKTOP : processEnv?.NOLO_DESKTOP) === "1" ||
+  (typeof window !== "undefined" && window.__NOLO_DESKTOP__ === true);
+export const isDesktopApp = getIsDesktopApp();

package/app/utils/fileUtils.ts

@@ -0,0 +1,229 @@
+// 文件路径: app/utils/fileUtils.ts
+
+import type { FileCategory } from "../types";
+
+const fileConstructor =
+  typeof globalThis !== "undefined" && typeof globalThis.File === "function"
+    ? globalThis.File
+    : undefined;
+
+export const isImageMimeType = (value: unknown): value is string =>
+  typeof value === "string" && value.toLowerCase().startsWith("image/");
+
+const IMAGE_FILE_NAME_RE = /\.(avif|bmp|gif|heic|heif|ico|jpe?g|png|svg|tiff?|webp)$/i;
+const VIDEO_FILE_NAME_RE = /\.(avi|m4v|mkv|mov|mp4|mpeg|mpg|webm)$/i;
+const AUDIO_FILE_NAME_RE = /\.(aac|flac|m4a|mp3|ogg|wav|weba)$/i;
+const DOCUMENT_FILE_NAME_RE =
+  /\.(csv|doc|docx|md|odt|pdf|ppt|pptx|rtf|txt|xls|xlsx)$/i;
+
+export const isImageFileName = (value: unknown): value is string =>
+  typeof value === "string" && IMAGE_FILE_NAME_RE.test(value.trim());
+
+export const formatFileSize = (bytes: number): string => {
+  if (!Number.isFinite(bytes) || bytes < 0) return "";
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const unitIndex = Math.min(
+    Math.floor(Math.log(bytes) / Math.log(1024)),
+    units.length - 1
+  );
+  const value = bytes / Math.pow(1024, unitIndex);
+  const digits = value >= 10 || unitIndex === 0 ? 0 : 1;
+  return `${value.toFixed(digits)} ${units[unitIndex]}`;
+};
+
+const MIME_FORMAT_LABELS: Record<string, string> = {
+  "application/pdf": "PDF",
+  "application/msword": "DOC",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "DOCX",
+  "application/vnd.ms-powerpoint": "PPT",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "PPTX",
+  "application/vnd.ms-excel": "XLS",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "XLSX",
+  "text/plain": "TXT",
+  "text/markdown": "MD",
+  "image/jpeg": "JPG",
+  "image/png": "PNG",
+  "image/webp": "WEBP",
+  "image/gif": "GIF",
+  "video/mp4": "MP4",
+  "video/quicktime": "MOV",
+  "audio/mpeg": "MP3",
+  "audio/wav": "WAV",
+  "audio/x-wav": "WAV",
+  "audio/mp4": "M4A",
+};
+
+export const resolveFileFormatLabel = ({
+  fileName,
+  mimeType,
+}: {
+  fileName?: unknown;
+  mimeType?: unknown;
+}): string | null => {
+  if (typeof fileName === "string") {
+    const normalizedName = fileName.trim();
+    const ext = normalizedName.includes(".")
+      ? normalizedName.split(".").pop()?.trim().toUpperCase()
+      : "";
+    if (ext) return ext;
+  }
+
+  if (typeof mimeType === "string") {
+    const normalizedMimeType = mimeType.trim().toLowerCase();
+    if (MIME_FORMAT_LABELS[normalizedMimeType]) {
+      return MIME_FORMAT_LABELS[normalizedMimeType];
+    }
+    const [, subtype] = normalizedMimeType.split("/");
+    if (subtype) {
+      return subtype.split("+")[0]?.split(".").pop()?.toUpperCase() ?? null;
+    }
+  }
+
+  return null;
+};
+
+export const getCompactFileMetaLabel = ({
+  fileName,
+  mimeType,
+  fileSize,
+}: {
+  fileName?: unknown;
+  mimeType?: unknown;
+  fileSize?: unknown;
+}): string | null => {
+  const formatLabel = resolveFileFormatLabel({ fileName, mimeType });
+  const sizeLabel =
+    typeof fileSize === "number" && Number.isFinite(fileSize)
+      ? formatFileSize(fileSize)
+      : null;
+
+  if (formatLabel && sizeLabel) return `${formatLabel} · ${sizeLabel}`;
+  return formatLabel ?? sizeLabel;
+};
+
+export const isVideoMimeType = (value: unknown): value is string =>
+  typeof value === "string" && value.toLowerCase().startsWith("video/");
+
+export const isAudioMimeType = (value: unknown): value is string =>
+  typeof value === "string" && value.toLowerCase().startsWith("audio/");
+
+export const isPdfMimeType = (value: unknown): value is string =>
+  typeof value === "string" && value.toLowerCase() === "application/pdf";
+
+export const isDocumentMimeType = (value: unknown): value is string => {
+  if (typeof value !== "string") return false;
+  const normalized = value.toLowerCase();
+  return (
+    isPdfMimeType(normalized) ||
+    normalized === "text/plain" ||
+    normalized === "text/markdown" ||
+    normalized === "text/csv" ||
+    normalized === "application/msword" ||
+    normalized ===
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document" ||
+    normalized === "application/vnd.ms-powerpoint" ||
+    normalized ===
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation" ||
+    normalized === "application/vnd.ms-excel" ||
+    normalized ===
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" ||
+    normalized === "application/rtf" ||
+    normalized === "application/vnd.oasis.opendocument.text"
+  );
+};
+
+export const resolveFileCategory = ({
+  mimeType,
+  fileName,
+}: {
+  mimeType?: unknown;
+  fileName?: unknown;
+}): FileCategory => {
+  if (isImageMimeType(mimeType) || isImageFileName(fileName)) return "image";
+  if (isVideoMimeType(mimeType) || (typeof fileName === "string" && VIDEO_FILE_NAME_RE.test(fileName.trim()))) {
+    return "video";
+  }
+  if (isAudioMimeType(mimeType) || (typeof fileName === "string" && AUDIO_FILE_NAME_RE.test(fileName.trim()))) {
+    return "audio";
+  }
+  if (isDocumentMimeType(mimeType) || (typeof fileName === "string" && DOCUMENT_FILE_NAME_RE.test(fileName.trim()))) {
+    return "document";
+  }
+  return "other";
+};
+
+export const isImageResourceLike = ({
+  kind,
+  mimeType,
+  fileName,
+  fileCategory,
+}: {
+  kind?: unknown;
+  mimeType?: unknown;
+  fileName?: unknown;
+  fileCategory?: unknown;
+}): boolean => {
+  if (fileCategory === "image") return true;
+  if (typeof kind === "string") {
+    const normalizedKind = kind.toLowerCase();
+    if (normalizedKind === "image" || isImageMimeType(normalizedKind)) {
+      return true;
+    }
+  }
+
+  return isImageMimeType(mimeType) || isImageFileName(fileName);
+};
+
+export const isBrowserFile = (value: unknown): value is File =>
+  !!fileConstructor && value instanceof fileConstructor;
+
+export const isImageFile = (value: unknown): value is File =>
+  isBrowserFile(value) && isImageMimeType(value.type);
+
+export const filterImageFiles = (values: Iterable<unknown>): File[] =>
+  Array.from(values).filter(isImageFile);
+
+/**
+ * 按是否为图片拆分文件数组:
+ * - 第 0 个数组是图片
+ * - 第 1 个数组是非图片
+ */
+export function splitFiles(files: File[]): [File[], File[]] {
+    return files.reduce(
+        (acc, file) => {
+            const index = isImageFile(file) ? 0 : 1;
+            acc[index].push(file);
+            return acc;
+        },
+        [[], []] as [File[], File[]]
+    );
+}
+
+/**
+ * 从 DataTransfer 中安全提取文件列表
+ * 兼容 dt.items 和 dt.files 两种情况
+ */
+export function extractFilesFromDataTransfer(
+    dt: DataTransfer | null
+): File[] {
+    if (!dt) return [];
+
+    const files: File[] = [];
+
+    if (dt.items && dt.items.length > 0) {
+        for (const item of Array.from(dt.items)) {
+            if (item.kind === "file") {
+                const file = item.getAsFile();
+                if (file) files.push(file);
+            }
+        }
+        if (files.length > 0) return files;
+    }
+
+    if (dt.files && dt.files.length > 0) {
+        return Array.from(dt.files);
+    }
+
+    return [];
+}

package/app/utils/imageUtils.ts

@@ -0,0 +1,274 @@
+// 文件路径: utils/imageUtils.ts
+import imageCompression from "browser-image-compression";
+
+/**
+ * 前端图片压缩配置（只包含我们实际用到的字段）。
+ * 可以按需扩展字段。
+ */
+export interface ImageCompressionOptions {
+  maxSizeMB?: number;
+  maxWidthOrHeight?: number;
+  useWebWorker?: boolean;
+  initialQuality?: number;
+  alwaysKeepResolution?: boolean;
+}
+
+/**
+ * 默认压缩参数：
+ * - 体积控制在 ~1.5MB 内
+ * - 最长边 1400 像素
+ * - 初始质量 0.9（画质较高）
+ * - 使用 WebWorker 避免主线程卡顿
+ */
+const DEFAULT_COMPRESSION_OPTIONS: Required<
+  Pick<
+    ImageCompressionOptions,
+    "maxSizeMB" | "maxWidthOrHeight" | "useWebWorker" | "initialQuality"
+  >
+> = {
+  maxSizeMB: 1.5,
+  maxWidthOrHeight: 1400,
+  useWebWorker: true,
+  initialQuality: 0.9,
+};
+
+const BYTES_PER_MB = 1024 * 1024;
+
+const toMegabytes = (bytes: number): number => bytes / BYTES_PER_MB;
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * 解析 dataURL，提取 mime 和 base64 数据部分。
+ */
+const parseDataUrl = (
+  dataUrl: string
+): { mime: string; base64: string } | null => {
+  const trimmed = dataUrl.trim();
+  const parts = trimmed.split(",");
+
+  if (parts.length < 2 || !parts[0] || !parts[1]) {
+    console.warn("[imageUtils] parseDataUrl: invalid data URL", {
+      hasHeader: !!parts[0],
+      hasBody: !!parts[1],
+    });
+    return null;
+  }
+
+  const header = parts[0];
+  const base64 = parts[1];
+
+  const mimeMatch = header.match(/:(.*?);/);
+  const mime = mimeMatch?.[1];
+
+  if (!mime) {
+    console.warn("[imageUtils] parseDataUrl: cannot extract mime from", header);
+    return null;
+  }
+
+  return { mime, base64 };
+};
+
+/**
+ * 将 data URL 字符串转回 File 对象。
+ * @param dataUrl 形如 "data:image/png;base64,..." 的字符串
+ * @param filename 生成 File 时使用的文件名
+ * @returns File 对象，失败时返回 null
+ */
+export function dataURLtoFile(
+  dataUrl: string,
+  filename: string
+): File | null {
+  try {
+    const parsed = parseDataUrl(dataUrl);
+    if (!parsed) return null;
+
+    const { mime, base64 } = parsed;
+
+    const binaryString = atob(base64);
+    const length = binaryString.length;
+    const u8arr = new Uint8Array(length);
+
+    for (let i = 0; i < length; i++) {
+      u8arr[i] = binaryString.charCodeAt(i);
+    }
+
+    return new File([u8arr], filename, { type: mime });
+  } catch (error) {
+    console.error("[imageUtils] Error converting data URL to File:", error);
+    return null;
+  }
+}
+
+const normalizeCompressedFile = (sourceFile: File, compressed: Blob | File): File => {
+  if (compressed instanceof File) {
+    return compressed;
+  }
+
+  return new File([compressed], sourceFile.name, {
+    type: compressed.type || sourceFile.type || "application/octet-stream",
+    lastModified: sourceFile.lastModified || Date.now(),
+  });
+};
+
+export async function compressImageFile(
+  imageFile: File,
+  options?: ImageCompressionOptions
+): Promise<File> {
+  const mergedOptions: ImageCompressionOptions = {
+    ...DEFAULT_COMPRESSION_OPTIONS,
+    ...options,
+  };
+
+  const originalSizeMB = toMegabytes(imageFile.size);
+  const targetSizeMB =
+    mergedOptions.maxSizeMB ?? DEFAULT_COMPRESSION_OPTIONS.maxSizeMB;
+
+  console.log(
+    `[imageUtils] compressImageFile: original size = ${originalSizeMB.toFixed(
+      2
+    )} MB`
+  );
+
+  if (originalSizeMB <= targetSizeMB) {
+    console.log(
+      "[imageUtils] compressImageFile: image already smaller than target, skip compression"
+    );
+    return imageFile;
+  }
+
+  try {
+    const compressedBlob = await imageCompression(imageFile, mergedOptions);
+    const compressedFile = normalizeCompressedFile(imageFile, compressedBlob);
+    const compressedSizeMB = toMegabytes(compressedFile.size);
+
+    console.log(
+      `[imageUtils] compressImageFile: compressed size = ${compressedSizeMB.toFixed(
+        2
+      )} MB (target <= ${targetSizeMB.toFixed(2)} MB)`
+    );
+
+    if (compressedFile.size >= imageFile.size) {
+      console.log(
+        "[imageUtils] compressImageFile: compressed file is not smaller, return original"
+      );
+      return imageFile;
+    }
+
+    return compressedFile;
+  } catch (error) {
+    console.error("[imageUtils] compressImageFile failed:", error);
+    return imageFile;
+  }
+}
+
+/**
+ * 压缩一张 dataURL 图片。
+ * 使用 browser-image-compression 库。
+ *
+ * @param imageDataUrl 原始图片的 dataURL（Base64）
+ * @param options 可选的压缩参数，会覆盖默认值
+ * @returns 压缩后的 dataURL；如果压缩失败或不划算，会返回原始 dataURL
+ */
+export async function compressImage(
+  imageDataUrl: string,
+  options?: ImageCompressionOptions
+): Promise<string> {
+  // 为转换生成一个“相对唯一”的文件名
+  const timestamp = Date.now();
+  const filename = `image_${timestamp}.png`; // 实际类型由 dataURL 决定
+
+  const imageFile = dataURLtoFile(imageDataUrl, filename);
+
+  if (!imageFile) {
+    console.warn(
+      "[imageUtils] compressImage: cannot convert data URL to File, return original"
+    );
+    return imageDataUrl;
+  }
+
+  try {
+    const compressedFile = await compressImageFile(imageFile, options);
+    if (compressedFile === imageFile) {
+      console.log(
+        "[imageUtils] compressImage: file-based compression kept original image"
+      );
+      return imageDataUrl;
+    }
+
+    const compressedDataUrl =
+      await imageCompression.getDataUrlFromFile(compressedFile);
+
+    return compressedDataUrl;
+  } catch (error) {
+    console.error("[imageUtils] compressImage failed:", error);
+    return imageDataUrl;
+  }
+}
+
+/**
+ * 等待 remote /file/content/:fileId 对应的图片 URL 可用。
+ * 通过创建 <img> 去加载这个 URL，避免 CORS 问题。
+ *
+ * 成功：在 maxWaitMs 内，某次加载 onload 触发。
+ * 失败：超时或每次都是 onerror。
+ */
+export interface WaitForFileReadyOptions {
+  /** 最大等待时间（毫秒），默认 4000ms */
+  maxWaitMs?: number;
+  /** 每次重试之间的间隔时间（毫秒），默认 250ms */
+  intervalMs?: number;
+}
+
+const appendNoCacheQuery = (url: string): string => {
+  const stamp = `_t=${Date.now()}`;
+  return url.includes("?") ? `${url}&${stamp}` : `${url}?${stamp}`;
+};
+
+const tryLoadImage = (url: string): Promise<boolean> =>
+  new Promise((resolve) => {
+    const img = new Image();
+
+    const cleanup = () => {
+      img.onload = null;
+      img.onerror = null;
+    };
+
+    img.onload = () => {
+      cleanup();
+      resolve(true);
+    };
+
+    img.onerror = () => {
+      cleanup();
+      resolve(false);
+    };
+
+    img.src = url;
+  });
+
+export const waitForFileReady = async (
+  url: string,
+  {
+    maxWaitMs = 4000,
+    intervalMs = 250,
+  }: WaitForFileReadyOptions = {}
+): Promise<boolean> => {
+  const start = Date.now();
+
+  while (Date.now() - start < maxWaitMs) {
+    const tryUrl = appendNoCacheQuery(url);
+    const ok = await tryLoadImage(tryUrl);
+
+    if (ok) {
+      console.debug("[imageUtils] waitForFileReady: image loaded for", url);
+      return true;
+    }
+
+    await sleep(intervalMs);
+  }
+
+  console.warn("[imageUtils] waitForFileReady: timeout for", url);
+  return false;
+};