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.6 KB
Raw Blame
/**
 * workdir 外远程文件取件(absPath → 可下载 URL)。
 *
 * 聊天 chip 的目标可能落在会话 workdir 之外(如 agent 写到 /tmp 的截图),
 * file-browser 的 relPath 通道(readFile / thumbnail / exportFile*)对这类
 * 路径一律拒绝。这里改走被控端 media:fetch 的绝对路径通道
 * (`xdt-file://open?path=<absPath>`,与文件浏览器 gallery 同一 scheme):
 * 被控端把文件上传 OSS → 手机 presign 换下载地址。安全边界与桌面控制端一致
 * ——media:fetch 故意不限 workdir,靠 device-link 的三道 gate(被控开关 /
 * 撤销黑名单 / channel 白名单)保证「等同本地访问」的信任级。
 *
 * 完整文件进入共用读取层,优先使用持久字节缓存、后台复验,不复用下述临时 URL。
 * 流式地址缓存策略:`xdt-file://` 不进被控端 mtime/size 感知
 * 的上传去重缓存(那只对 `xdt-image://` 生效,见 desktop mediaFetch.ts),手机侧
 * 又没有 mtime 来源可验证文件是否被覆写——若按 presign 全期(约 1 小时)缓存,
 * 同路径文件被 agent 覆写后会一直吃到旧字节。因此这里只做**短 TTL** 缓存:
 * 覆盖同一次预览/分享内的连续消费(图片页取原图 → lightbox → 导出分享),
 * 跨时间点重进则重新取件拿新字节;条目数带上限 FIFO 淘汰(对齐被控端
 * rememberUpload 的写法),长会话不累积。
 */
import { withTransientRemoteRetry } from '@/device-link/remoteRetry';
import { i18n } from '@/i18n';
import type {
  FileBrowserReadFileResult,
  MobileMakerTransport,
  RemoteTextFilePreviewResult,
} from '@/device-link/mobileMakerTransport';
import { releasePeerMedia } from '@/device-link/peerFileRegistry';
import {
  effectiveRemoteMediaSshContext,
  remoteFileMediaUrl,
  type RemoteMediaFetchConstraints,
  type RemoteMediaSshContext,
} from '@/session/fileBrowserGallery';
import {
  isResolvedRemoteMediaFresh,
  resolveMobileRemoteMedia,
  type MobileRemoteMediaPresignResult,
  type MobileResolvedRemoteMedia,
} from '@/session/remoteMedia';

export interface RemoteAbsFileFetchDeps {
  stream?: boolean;
  maker: Pick<MobileMakerTransport, 'fetchRemoteMedia'>;
  deviceId: string;
  openLink: (deviceId: string) => Promise<unknown>;
  presignGet: (ossKey: string) => Promise<MobileRemoteMediaPresignResult>;
  deleteOssObject?: (key: string) => void;
  /** 取消信号(如页面卸载、导出提示上的「取消」):中止取件,不再重试。 */
  isCancelled?: () => boolean;
}

/** 缓存 TTL:只护住一次预览/分享动作链,把「同路径覆写吃旧字节」窗口压到 1 分钟。 */
const CACHE_TTL_MS = 60 * 1000;
/** 条目上限:超出按插入序淘汰最旧(Map 迭代序 = 插入序)。 */
const CACHE_MAX = 64;

interface CacheEntry {
  media: MobileResolvedRemoteMedia;
  cachedAt: number;
}

/** 短 TTL 取件结果缓存(模块级;命中同时要求 presign 未过期)。 */
const cache = new Map<string, CacheEntry>();

function lookupCache(key: string, now: number): MobileResolvedRemoteMedia | null {
  const hit = cache.get(key);
  if (!hit) return null;
  if (now - hit.cachedAt >= CACHE_TTL_MS || !isResolvedRemoteMediaFresh(hit.media, now)) {
    cache.delete(key);
    return null;
  }
  return hit.media;
}

function rememberFetch(key: string, media: MobileResolvedRemoteMedia, now: number): void {
  cache.delete(key); // 重插保持插入序,FIFO 淘汰最旧
  cache.set(key, { media, cachedAt: now });
  while (cache.size > CACHE_MAX) {
    const oldest = cache.keys().next().value;
    if (oldest === undefined) break;
    cache.delete(oldest);
  }
}

/**
 * absPath → presign 下载地址。并发去重不做(调用场景是单文件预览/分享,
 * 不存在列表级风暴)。
 */
export async function fetchRemoteAbsFileToUrl(
  deps: RemoteAbsFileFetchDeps,
  absPath: string,
  /**
   * SSH 会话的取件上下文(见 remoteFileMediaUrl):不传会让被控端把 absPath 当**本机**
   * 路径解析。**必须进缓存键** —— 同一路径在不同远端主机上是不同文件,漏进去会串味。
   */
  ssh?: RemoteMediaSshContext | null,
): Promise<string> {
  // 缓存键与 URL 必须走**同一份**「有效 SSH 上下文」判定(review P2):只看 `ssh` 对象是否
  // 存在会让字段为空/带空白的对象把键分叉,而 URL 那边已经退化成不带 SSH 参数(被控端按
  // 本机路径取件)—— 于是同一次取件永远命中不了缓存,每次都白发一轮请求。
  const eff = effectiveRemoteMediaSshContext(ssh);
  const sshKey = eff
    ? `${eff.sessionId}\u0000${eff.remoteHostId}\u0000${eff.workdir}`
    : '';
  const key = `${deps.deviceId}\u0000${absPath}\u0000${sshKey}\u0000${deps.stream === false ? 'file' : 'stream'}`;
  const cached = deps.stream === false ? null : lookupCache(key, Date.now());
  if (cached) return cached.url;
  // 与 exportRemoteFileToUrl 同一写法:轮询 isCancelled 转成取件的 AbortSignal。
  const abort = deps.isCancelled ? new AbortController() : null;
  const check = () => {
    if (deps.isCancelled?.()) abort?.abort();
  };
  const assertActive = () => {
    check();
    if (abort?.signal.aborted) throw new Error(i18n.t('files.export.leftPage'));
  };
  const timer = abort ? setInterval(check, 100) : null;
  try {
    const fetchOpts = {
      beforeFetch: () => deps.openLink(deps.deviceId),
      ...(deps.deleteOssObject ? { discardBackgroundOssKey: deps.deleteOssObject } : {}),
      ...(deps.stream === false ? { stream: false } : {}),
      ...(abort ? { signal: abort.signal } : {}),
    };
    const resolved = await withTransientRemoteRetry(async () => {
      assertActive();
      // kind 只影响结果的 previewable 标志(此处不消费),按 image 占位。
      return resolveMobileRemoteMedia(
        { kind: 'image', url: remoteFileMediaUrl(absPath, undefined, ssh) },
        { fetchRemoteMedia: deps.maker.fetchRemoteMedia, presignGet: deps.presignGet },
        Object.keys(fetchOpts).length ? fetchOpts : undefined,
      );
    });
    // Only the local copy can outlive its temporary cloud object.
    if (resolved.ossKey && resolved.url.startsWith('file://')) {
      deps.deleteOssObject?.(resolved.ossKey);
    }
    if (deps.stream !== false) rememberFetch(key, resolved, Date.now());
    assertActive();
    return resolved.url;
  } finally {
    if (timer) clearInterval(timer);
  }
}

/**
 * 一次性取件:返回**完整** resolved 结果(含 ossKey)且**不进共享缓存**。
 *
 * 给「取回字节后立刻转成 data: URI」的消费方用(HTML 渲染态的同目录资源):
 *  - 需要 ossKey 才能在用完后 DELETE 掉 OSS 对象 —— fetchRemoteAbsFileToUrl 只回 url、
 *    丢掉 ossKey,于是每个资源都会遗留一个在世对象,一页最多 32 个,反复进出还会累积
 *    (review P1)。
 *  - 不进那份 60s TTL 缓存:对象用完即删,缓存命中会回一个已被删除的死 URL。
 */
export async function fetchRemoteAbsFileOnce(
  deps: RemoteAbsFileFetchDeps,
  absPath: string,
  ssh?: RemoteMediaSshContext | null,
  /**
   * 每次上传成功、拿到 ossKey 时回调(可能被调用多次,见下)。
   *
   * **调用方必须累加收集,并对每个 key 都做 best-effort DELETE**:
   *  - presign 失败(弱网 / 回包非法)会让 resolveMobileRemoteMedia 在返回之前抛错,
   *    此时对象已经在 OSS 上,但调用方拿不到 resolved 结果 —— 只围绕结果写 finally 的话
   *    这个对象永久遗留(review P1);
   *  - withTransientRemoteRetry 的每一次重试都可能再上传一份,产出**不同**的 key,
   *    所以只记最后一个同样会漏。
   */
  onOssKey?: (ossKey: string) => void,
  /**
   * 服务端强制约束(baseDir / maxBytes)。**必须在这里传**,而不是只在手机侧判:
   * 手机拿到 `media.size` 时被控端已经上传完 OSS(SSH 场景还先整份拉到 Desktop 磁盘缓存),
   * 流量与磁盘已经花掉了(review P2)。老被控端忽略这两个参数,故手机侧判断照旧保留。
   */
  constraints?: RemoteMediaFetchConstraints | null,
  signal?: AbortSignal,
  onProgress?: (loaded: number, total: number) => void,
): Promise<MobileResolvedRemoteMedia> {
  return withTransientRemoteRetry(async () => {
    const assertActive = () => { if (signal?.aborted) throw new Error('PREVIEW_CANCELLED'); };
    assertActive();
    await deps.openLink(deps.deviceId);
    assertActive();
    // kind 只影响结果的 previewable 标志(此处不消费),按 image 占位。
    return resolveMobileRemoteMedia(
      { kind: 'image', url: remoteFileMediaUrl(absPath, undefined, ssh, constraints) },
      { fetchRemoteMedia: deps.maker.fetchRemoteMedia, presignGet: deps.presignGet },
      // HTML already restores its visible snapshot before calling here. Returning
      // another stale snapshot would write old bytes back into that preview cache.
      { onOssKey, signal, stream: false, skipCache: true, ...(onProgress ? { onProgress } : {}) },
    );
  });
}

/**
 * text-file:read-preview 回包 → file-browser readFile 同构结果(absPath
 * 单文件模式专用,让预览页文本渲染零分支)。该通道返回纯文本(无 gzip /
 * truncated 语义),oversize 映射 OVERSIZE 供「超上限,可下载」占位复用。
 */
export function adaptTextFilePreviewResult(
  absPath: string,
  res: RemoteTextFilePreviewResult,
): FileBrowserReadFileResult {
  if (res.success && typeof res.data === 'string') {
    return {
      ok: true,
      data: { relPath: absPath, content: res.data, size: res.size, mtimeMs: 0 },
    };
  }
  if (res.reason === 'oversize') {
    return {
      ok: false,
      code: 'OVERSIZE',
      stat: { relPath: absPath, type: 'file', size: res.size, mtimeMs: 0 },
    };
  }
  const message = res.reason === 'not_found'
    ? i18n.t('composer.attachments.fileNotFound')
    : res.reason === 'forbidden'
      ? i18n.t('composer.attachments.pathNotReadable')
      : res.error ?? i18n.t('composer.attachments.readFailed');
  return { ok: false, code: 'READ_FAILED', message };
}

/** Size-limited text fallback; uses existing transfer/cache and temporary-file cleanup. */
export async function readRemoteTextFilePreview(
  deps: RemoteAbsFileFetchDeps & {
    readPreview: (path: string) => Promise<RemoteTextFilePreviewResult>;
    isCurrent: () => boolean;
  },
  path: string,
  signal: AbortSignal = new AbortController().signal,
): Promise<RemoteTextFilePreviewResult> {
  const assertActive = () => {
    if (signal?.aborted || !deps.isCurrent()) throw new Error('PREVIEW_CANCELLED');
  };
  assertActive();
  let preview: RemoteTextFilePreviewResult | undefined;
  try {
    preview = await deps.readPreview(path);
  } catch (error) {
    // Older Hosts ignore the opt-in and return their existing compact error.
    // Permission, missing-file and connection failures must never bypass the text reader.
    if (!error || typeof error !== 'object' || !('code' in error) || error.code !== 'PAYLOAD_TOO_LARGE') throw error;
  }
  assertActive();
  if (preview && (!preview.success || !preview.transferRequired)) return preview;
  const maxBytes = 10 * 1024 * 1024;
  const uploaded = new Set<string>();
  let localUri: string | undefined;
  try {
    const media = await resolveMobileRemoteMedia(
      { kind: 'image', url: remoteFileMediaUrl(path, undefined, undefined, { maxBytes }) },
      { fetchRemoteMedia: deps.maker.fetchRemoteMedia, presignGet: deps.presignGet },
      // The visible text cache already provides the stale snapshot. This read
      // must validate the Host version before updating that snapshot again.
      { signal, stream: false, revalidate: true, beforeFetch: async () => {
        assertActive();
        await deps.openLink(deps.deviceId);
        assertActive();
      }, onOssKey: (key) => uploaded.add(key) },
    );
    if (media.url.startsWith('file://')) localUri = media.url;
    assertActive();
    if (!Number.isSafeInteger(media.size) || media.size < 0) throw new Error('PREVIEW_CHANGED');
    if (media.size > maxBytes) return { success: false, reason: 'oversize', size: media.size, limitMb: 10 };
    const { withDownloadedRemoteMediaFile } = await import('./remoteMediaDiskCacheExpo');
    const result = await withDownloadedRemoteMediaFile(media.url, media.mimeType, maxBytes, async (file) => {
      assertActive();
      if (file.size !== media.size) throw new Error('PREVIEW_CHANGED');
      const data = await file.text();
      assertActive();
      return { success: true, data, size: media.size, limitMb: 10 };
    }, signal);
    assertActive();
    if (!result) throw new Error('PREVIEW_READ_FAILED');
    return result;
  } finally {
    if (localUri) releasePeerMedia(localUri);
    for (const key of uploaded) deps.deleteOssObject?.(key);
  }
}