Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

12.4 KB
Raw Blame
/**
 * remoteMediaDiskCacheExpo.ts — remoteMediaDiskCache 的 expo-file-system IO 适配。
 * ---------------------------------------------------------------------------
 * 目录固定在系统 cache 区(Paths.cache/remote-media):OS 低存储可整体回收,
 * 回收后当冷缓存重新取件即可(纯模块的 lookup 自愈已处理文件丢失)。
 * expo-file-system 的原生模块随 expo 核心包已链接进现有原生构建,本文件只是
 * JS 层引用,不影响 fingerprint(以 mobile:release:check 实测为准)。
 */
import { Directory, File, Paths } from "expo-file-system";
import { releasePeerMedia } from '@/device-link/peerFileRegistry';

import {
  extOfMime,
  type RemoteMediaDiskCacheIO,
} from "@/session/remoteMediaDiskCache";

const CACHE_DIR_NAME = "remote-media";
const INDEX_FILE_NAME = "index.json";
const INDEX_TMP_NAME = "index.json.tmp";
const SHARE_TMP_DIR_NAME = "remote-media-share";

/**
 * 可中止的 http 下载:新 API 的 File.downloadFileAsync 无法中途停止,这里沿用
 * androidInstaller 的 legacy DownloadResumable + cancelAsync;取消后不等
 * downloadAsync(cancelAsync 后它未必 settle),等 cancelAsync 结算后删掉半成品。
 */
async function downloadCancellable(
  url: string,
  target: File,
  signal: AbortSignal,
  maxBytes?: number,
): Promise<File> {
  const FileSystem = await import("expo-file-system/legacy");
  let rejectStopped: (reason: Error) => void = () => undefined;
  const stopped = new Promise<never>((_, reject) => {
    rejectStopped = reject;
  });
  const task = FileSystem.createDownloadResumable(url, target.uri, {}, (progress) => {
    if (maxBytes !== undefined && progress.totalBytesWritten > maxBytes) {
      rejectStopped(new Error('PREVIEW_TOO_LARGE'));
      void task.cancelAsync().catch(() => undefined);
    }
  });
  const stop = () => {
    rejectStopped(new Error("DOWNLOAD_CANCELLED"));
    void task.cancelAsync().catch(() => undefined);
  };
  signal.addEventListener("abort", stop, { once: true });
  try {
    if (signal.aborted) throw new Error("DOWNLOAD_CANCELLED");
    const result = await Promise.race([task.downloadAsync(), stopped]);
    if (!result || result.status < 200 || result.status >= 300)
      throw new Error("DOWNLOAD_FAILED");
    return target;
  } catch (error) {
    // 先等原生任务确认停止再删,否则可能删后又被写回半成品(同 androidInstaller)。
    await task.cancelAsync().catch(() => undefined);
    await FileSystem.deleteAsync(target.uri, { idempotent: true }).catch(
      () => undefined,
    );
    throw error;
  } finally {
    signal.removeEventListener("abort", stop);
  }
}

async function copyRemoteFile(
  url: string,
  target: File,
  signal?: AbortSignal,
  maxBytes?: number,
): Promise<File> {
  if (url.startsWith("file://")) {
    const source = new File(url);
    if (maxBytes !== undefined && source.size > maxBytes) throw new Error('PREVIEW_TOO_LARGE');
    await source.copy(target);
    return target;
  }
  if (url.startsWith("data:")) {
    const match = /^data:[\w.+-]+\/[\w.+-]+;base64,([A-Za-z0-9+/=]*)$/.exec(
      url,
    );
    if (!match || match[1].length > 1024 * 1024)
      throw new Error("INVALID_INLINE_FILE");
    target.write(Uint8Array.from(atob(match[1]), (char) => char.charCodeAt(0)));
    return target;
  }
  if (signal || maxBytes !== undefined) return downloadCancellable(url, target, signal ?? new AbortController().signal, maxBytes);
  return File.downloadFileAsync(url, target, { idempotent: true });
}

/** A visible preview owns its copy; transport staging and cache eviction cannot expire it. */
export async function retainRemoteFilePreview(url: string, mimeType: string, fileName: string) {
  if (!url.startsWith('file://') && !url.startsWith('data:')) return { uri: url, release() {} };
  const uri = await downloadRemoteMediaShareTemp(url, mimeType, fileName);
  if (!uri) throw new Error('PREVIEW_CACHE_FAILED');
  return {
    uri,
    release() {
      try { const file = new File(uri); if (file.exists) file.delete(); } catch { /* OS reclaims cache files. */ }
    },
  };
}

/**
 * 一次性分享临时文件:超出磁盘缓存预算的对象走 store 会被 LRU 立即逐出,
 * lookup 拿不到 → 分享失败。这里绕开 LRU 直接下到独立临时目录,只服务本次
 * 分享;文件留在系统 cache 区,OS 低存储时统一回收(罕见路径,不做主动清理)。
 * 传入 signal 时 http 下载可被「取消」真正中止(停止流量、删半成品);任何来源在
 * 取消后都不留分享副本,返回 null。
 */
export async function downloadRemoteMediaShareTemp(
  url: string,
  mimeType: string,
  fileName?: string,
  signal?: AbortSignal,
): Promise<string | null> {
  try {
    if (signal?.aborted) return null;
    const dir = new Directory(Paths.cache, SHARE_TMP_DIR_NAME);
    dir.create({ intermediates: true, idempotent: true });
    const unique = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
    // 带原始文件名时落进一次性唯一子目录:分享单里显示真实文件名与扩展名
    // (PDF/视频/压缩包等非图片类型靠扩展名保住类型识别,extOfMime 只认图片
    // mime,兜底 .img 会让接收方无法正确预览);子目录唯一化避免同名冲突。
    const safeName = fileName?.replace(/[\\/:*?"<>|]/g, "_").trim();
    let target: File;
    if (safeName) {
      const sub = new Directory(dir, unique);
      sub.create({ intermediates: true, idempotent: true });
      target = new File(sub, safeName);
    } else {
      target = new File(dir, `share-${unique}.${extOfMime(mimeType)}`);
    }
    const file = await copyRemoteFile(url, target, signal);
    // 直连 file:// 复制与 data: 写入无法中途停止:结束后已取消就删掉这份副本。
    if (signal?.aborted) {
      if (file.exists) file.delete();
      return null;
    }
    return file.exists ? file.uri : null;
  } catch {
    return null; // 分享失败由调用方兜底提示
  } finally {
    // Sharing and visible previews both own their new copy after this handoff.
    // Only registered transport staging is released; ordinary local files stay.
    if (url.startsWith('file://')) releasePeerMedia(url);
  }
}

/**
 * 下载 → 读成 `data:` URI → 删临时文件。
 *
 * 给 HTML 渲染态的同目录资源用:**预签名地址只在 app 侧使用,绝不写进页面**。
 * 写进页面等于把一个 bearer 凭证交给可执行的不可信文档 —— 内联脚本能读 `img.src`
 * 再以 no-cors 外传,第三方就能在有效期内下载被控端文件(review P1 实捉)。
 *
 * 超过 maxBytes 返回 null(调用方保留原引用,渲染成破图):data URI 会整份进 JS 字符串
 * 与 DOM,不设上限会被一张大图撑爆内存。
 */
export async function downloadRemoteMediaAsDataUri(
  url: string,
  mimeType: string,
  maxBytes: number,
): Promise<string | null> {
  return withDownloadedRemoteMediaFile(
    url,
    mimeType,
    maxBytes,
    async (file) => {
      const base64 = await file.base64();
      return base64 ? `data:${mimeType};base64,${base64}` : null;
    },
  );
}

/** Consume a size-bounded download before deleting its private temporary file. */
export async function withDownloadedRemoteMediaFile<T>(
  url: string,
  mimeType: string,
  maxBytes: number,
  read: (file: File) => Promise<T | null>,
  signal?: AbortSignal,
  onTooLarge?: () => void,
  options?: { allowEmpty?: boolean },
): Promise<T | null> {
  const dir = new Directory(Paths.cache, SHARE_TMP_DIR_NAME);
  let target: File | null = null;
  try {
    if (signal?.aborted) return null;
    dir.create({ intermediates: true, idempotent: true });
    const unique = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
    target = new File(dir, `res-${unique}.${extOfMime(mimeType)}`);
    const file = await copyRemoteFile(url, target, signal, signal ? maxBytes : undefined);
    const size = file.size ?? 0;
    if (signal?.aborted || size < 0 || (size === 0 && !options?.allowEmpty)) return null;
    if (size > maxBytes) {
      onTooLarge?.();
      return null;
    }
    const result = await read(file);
    return signal?.aborted ? null : result;
  } catch (error) {
    if (error instanceof Error && error.message === 'PREVIEW_TOO_LARGE') onTooLarge?.();
    return null;
  } finally {
    if (url.startsWith('file://')) releasePeerMedia(url);
    // 临时文件用完即删:资源可能几十个,留着会把 cache 目录堆满。
    try {
      target?.delete();
    } catch {
      // 删不掉不影响结果(系统会回收 cache 目录)。
    }
  }
}

export function createExpoRemoteMediaDiskCacheIO(namespace?: string): RemoteMediaDiskCacheIO {
  if (namespace && !/^files-[a-f0-9]{64}$/.test(namespace)) throw new Error('INVALID_CACHE_NAMESPACE');
  const root = new Directory(Paths.cache, CACHE_DIR_NAME);
  const dir = namespace ? new Directory(root, namespace) : root;
  return {
    ensureDir() {
      dir.create({ intermediates: true, idempotent: true });
    },
    async readIndexText() {
      const file = new File(dir, INDEX_FILE_NAME);
      if (!file.exists) return null;
      return file.text();
    },
    writeIndexText(text) {
      // 原子写:先写临时文件,再 overwrite move 顶替正式 index——覆盖写中途
      // App 被杀不会留下截断 JSON(损坏索引会让全部落盘文件变成不可回收孤儿)。
      const tmp = new File(dir, INDEX_TMP_NAME);
      tmp.write(text);
      tmp.moveSync(new File(dir, INDEX_FILE_NAME), { overwrite: true });
    },
    fileExists(name) {
      return new File(dir, name).exists;
    },
    fileSize(name) {
      return new File(dir, name).size ?? -1;
    },
    fileUri(name) {
      return new File(dir, name).uri;
    },
    deleteFile(name) {
      const file = new File(dir, name);
      if (file.exists) file.delete();
    },
    async writeFileBase64(name, base64) {
      // 契约同 download:先写临时名,成功后原子顶替,失败不动既有同名好文件。
      // base64 → 字节交给 legacy writeAsStringAsync 原生解码(新 API File.write
      // 只收 string/Uint8Array,JS 侧手动 atob 解大图纯浪费);残留 .wb.tmp 由
      // init 对账当孤儿清掉。
      const tmp = new File(dir, `${name}.wb.tmp`);
      try {
        const FileSystem = await import("expo-file-system/legacy");
        await FileSystem.writeAsStringAsync(tmp.uri, base64, {
          encoding: FileSystem.EncodingType.Base64,
        });
        const size = tmp.size ?? 0;
        if (size < 0) {
          if (tmp.exists) tmp.delete();
          return null;
        }
        tmp.moveSync(new File(dir, name), { overwrite: true });
        return size;
      } catch {
        try {
          if (tmp.exists) tmp.delete();
        } catch {
          // best-effort:残留临时文件由 init 对账兜底
        }
        return null; // 缓存是纯优化,写入失败静默(渲染回退 data URI)
      }
    },
    async download(url, name, expectedSize) {
      // 契约(RemoteMediaDiskCacheIO.download):失败不得破坏既有同名好文件。
      // downloadFileAsync 直接写目标(Android 失败可留半成品),所以先下到临时名,
      // 成功后原子顶替;仅明确声明 expectedSize === 0 时接受空文件。
      // 失败或意外空文件不动现有文件。残留的 .dl.tmp 由 init 对账当孤儿清掉。
      const tmp = new File(dir, `${name}.dl.tmp`);
      try {
        const downloaded = await copyRemoteFile(url, tmp);
        const size = downloaded.size ?? -1;
        if (!downloaded.exists || size < 0 || (size === 0 && expectedSize !== 0) ||
            (expectedSize !== undefined && size !== expectedSize)) {
          if (tmp.exists) tmp.delete();
          return null;
        }
        tmp.moveSync(new File(dir, name), { overwrite: true });
        return size;
      } catch {
        try {
          if (tmp.exists) tmp.delete();
        } catch {
          // best-effort:残留临时文件由 init 对账兜底
        }
        return null; // 缓存是纯优化,下载失败静默(下次取件再试)
      }
    },
    listFiles() {
      // 数据文件名列表(契约:不含 index 自身与临时文件),供 init 对账删孤儿。
      // .dl.tmp 残留刻意**不**过滤——它们不在 index 里,正该被对账清掉。
      return dir
        .list()
        .filter((item): item is File => item instanceof File)
        .map((file) => file.name)
        .filter((name) => name !== INDEX_FILE_NAME && name !== INDEX_TMP_NAME);
    },
  };
}