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。

15.1 KB
Raw Blame
/**
 * Custom marketplace icon loader.
 *
 * Main owns discovery and filesystem access. Renderer batches visible requests, keeps bytes in a
 * bounded shared LRU, and treats customIconKey as a snapshot cache generation rather than a byte
 * content hash. Main verifies every materialized read; a refreshed projection gets a new key.
 * [PROTOCOL]: 变更时更新此头部,然后检查 CLAUDE.md
 */

import { useCallback, useEffect, useMemo, useState, useSyncExternalStore } from 'react';

import type {
  PluginMarketItem,
  PluginMarketLocalIconRequest,
  PluginMarketLocalIconResult,
} from '../../../../shared/pluginMarket';
import {
  isPluginMarketCustomIconKey,
  pluginMarketCustomIconSourceToken,
} from '../../../../shared/pluginMarket';

type LocalIconStatus = 'idle' | 'queued' | 'loading' | 'loaded' | 'missing' | 'retryable';

interface LocalIconSnapshot {
  status: LocalIconStatus;
  dataUrl?: string;
}

interface LocalIconRecord {
  request: PluginMarketLocalIconRequest;
  snapshot: LocalIconSnapshot;
  listeners: Set<() => void>;
  pinCount: number;
  lastUsed: number;
  dataSize: number;
  retryCount: number;
  retryTimer: ReturnType<typeof setTimeout> | null;
  loadAttempt: number;
}

interface LocalIconBatchEntry {
  record: LocalIconRecord;
  attempt: number;
}

const EMPTY_SNAPSHOT: LocalIconSnapshot = Object.freeze({ status: 'idle' });
const BATCH_SIZE = 8;
const RECORD_CACHE_LIMIT = 128;
const DATA_URL_CACHE_BUDGET = 16 * 1024 * 1024;
const LOCAL_ICON_REQUEST_TIMEOUT_MS = 10_000;
const MAX_UNSETTLED_LOCAL_ICON_REQUESTS = 2;
const RETRY_DELAYS_MS = [1_000, 5_000, 30_000] as const;
const records = new Map<string, LocalIconRecord>();
const queuedKeys = new Set<string>();
const transportBlockedKeys = new Set<string>();
const unsettledLocalIconRequests = new Map<object, string>();
let flushScheduled = false;
let flushInFlight = false;
let pruneScheduled = false;
let totalDataSize = 0;

function requestKey(request: PluginMarketLocalIconRequest): string {
  return `${request.pluginId}:${request.expectedIconKey}`;
}

function requestSourceKey(request: PluginMarketLocalIconRequest): string {
  return pluginMarketCustomIconSourceToken(request.expectedIconKey) ?? request.pluginId;
}

function hasUnsettledRequestForSource(sourceKey: string): boolean {
  for (const unsettledSourceKey of unsettledLocalIconRequests.values()) {
    if (unsettledSourceKey === sourceKey) return true;
  }
  return false;
}

function recordFor(request: PluginMarketLocalIconRequest): LocalIconRecord {
  const key = requestKey(request);
  const existing = records.get(key);
  if (existing) return existing;
  const created: LocalIconRecord = {
    request,
    snapshot: EMPTY_SNAPSHOT,
    listeners: new Set(),
    pinCount: 0,
    lastUsed: Date.now(),
    dataSize: 0,
    retryCount: 0,
    retryTimer: null,
    loadAttempt: 0,
  };
  records.set(key, created);
  scheduleRecordPrune();
  return created;
}

function canRemoveRecord(record: LocalIconRecord): boolean {
  return (
    record.pinCount === 0 &&
    record.listeners.size === 0 &&
    record.snapshot.status !== 'queued' &&
    record.snapshot.status !== 'loading'
  );
}

function removeRecord(record: LocalIconRecord): void {
  if (!canRemoveRecord(record)) return;
  if (record.retryTimer !== null) {
    clearTimeout(record.retryTimer);
    record.retryTimer = null;
  }
  queuedKeys.delete(requestKey(record.request));
  transportBlockedKeys.delete(requestKey(record.request));
  if (record.dataSize > 0) {
    totalDataSize -= record.dataSize;
    record.dataSize = 0;
  }
  records.delete(requestKey(record.request));
}

function pruneRecords(): void {
  if (records.size <= RECORD_CACHE_LIMIT) return;
  const candidates = [...records.values()]
    .filter(canRemoveRecord)
    .sort((a, b) => a.lastUsed - b.lastUsed);
  for (const record of candidates) {
    removeRecord(record);
    if (records.size <= RECORD_CACHE_LIMIT) break;
  }
}

function scheduleRecordPrune(): void {
  if (pruneScheduled) return;
  pruneScheduled = true;
  queueMicrotask(() => {
    pruneScheduled = false;
    pruneRecords();
  });
}

function publish(record: LocalIconRecord, snapshot: LocalIconSnapshot): void {
  if (record.dataSize > 0) {
    totalDataSize -= record.dataSize;
    record.dataSize = 0;
  }
  record.snapshot = snapshot;
  if (snapshot.status === 'loaded' && snapshot.dataUrl) {
    record.dataSize = snapshot.dataUrl.length;
    totalDataSize += record.dataSize;
  }
  record.lastUsed = Date.now();
  for (const listener of record.listeners) listener();
}

function evictUnpinnedData(): void {
  if (totalDataSize <= DATA_URL_CACHE_BUDGET) return;
  const candidates = [...records.values()]
    .filter((record) => record.pinCount === 0 && record.snapshot.status === 'loaded')
    .sort((a, b) => a.lastUsed - b.lastUsed);
  for (const record of candidates) {
    publish(record, EMPTY_SNAPSHOT);
    if (totalDataSize <= DATA_URL_CACHE_BUDGET) break;
  }
}

function scheduleFlush(): void {
  if (flushScheduled) return;
  flushScheduled = true;
  queueMicrotask(() => void flushQueue());
}

function queueRecord(record: LocalIconRecord): void {
  if (record.snapshot.status !== 'idle' && record.snapshot.status !== 'retryable') {
    return;
  }
  if (record.retryTimer !== null) return;
  transportBlockedKeys.delete(requestKey(record.request));
  publish(record, { status: 'queued' });
  queuedKeys.add(requestKey(record.request));
  scheduleFlush();
}

function scheduleRetry(record: LocalIconRecord): void {
  if (record.pinCount === 0 || record.retryTimer !== null) return;
  const delay = RETRY_DELAYS_MS[record.retryCount];
  if (delay === undefined) {
    publish(record, { status: 'missing' });
    return;
  }
  record.retryCount += 1;
  record.retryTimer = setTimeout(() => {
    record.retryTimer = null;
    queueRecord(record);
  }, delay);
}

function markRetryable(record: LocalIconRecord): void {
  publish(record, { status: 'retryable' });
  scheduleRetry(record);
}

function parkForTransportCapacity(record: LocalIconRecord): void {
  publish(record, { status: 'retryable' });
  transportBlockedKeys.add(requestKey(record.request));
}

function wakeTransportBlockedRecords(): void {
  for (const key of [...transportBlockedKeys]) {
    const record = records.get(key);
    transportBlockedKeys.delete(key);
    if (record?.pinCount && record.snapshot.status === 'retryable' && record.retryTimer === null) {
      queueRecord(record);
    }
  }
  pruneRecords();
}

function localIconsWithinTimeoutFromPromise(
  request: Promise<PluginMarketLocalIconResult[]>,
): Promise<PluginMarketLocalIconResult[]> {
  let timer: ReturnType<typeof setTimeout> | undefined;
  const timeout = new Promise<never>((_resolve, reject) => {
    timer = setTimeout(
      () => reject(new Error('custom marketplace icon request timed out')),
      LOCAL_ICON_REQUEST_TIMEOUT_MS,
    );
  });
  // Electron invoke cannot be cancelled from Renderer. Promise.race only releases this batch;
  // loadAttempt below prevents a late response from overwriting a retried record.
  return Promise.race([request, timeout]).finally(() => {
    if (timer !== undefined) clearTimeout(timer);
  }) as Promise<PluginMarketLocalIconResult[]>;
}

function trackUnsettledLocalIconRequest(
  request: Promise<PluginMarketLocalIconResult[]>,
  marketKey: string,
): void {
  const token = {};
  unsettledLocalIconRequests.set(token, marketKey);
  const release = () => {
    if (!unsettledLocalIconRequests.delete(token)) return;
    wakeTransportBlockedRecords();
  };
  void request.then(
    () => release(),
    () => release(),
  );
}
function applyResult(record: LocalIconRecord, result: PluginMarketLocalIconResult): void {
  if (result.status === 'loaded') {
    publish(record, { status: 'loaded', dataUrl: result.dataUrl });
    evictUnpinnedData();
    pruneRecords();
    return;
  }
  if (result.status === 'missing') {
    publish(record, { status: 'missing' });
    pruneRecords();
    return;
  }
  markRetryable(record);
  pruneRecords();
}

async function flushQueue(): Promise<void> {
  flushScheduled = false;
  if (flushInFlight) return;
  const batch: LocalIconBatchEntry[] = [];
  if (unsettledLocalIconRequests.size >= MAX_UNSETTLED_LOCAL_ICON_REQUESTS) {
    for (const key of queuedKeys) {
      queuedKeys.delete(key);
      const record = records.get(key);
      if (!record || record.snapshot.status !== 'queued') continue;
      // 这批还没有发出 IPC,不能消耗内容读取的重试预算。旧请求
      // settle 释放槽位后会唤醒仍在可视区的记录。
      parkForTransportCapacity(record);
    }
    pruneRecords();
    return;
  }
  const pendingKeys = [...queuedKeys];
  const firstPendingRecord = pendingKeys
    .map((key) => records.get(key))
    .find(
      (record): record is LocalIconRecord =>
        record?.snapshot.status === 'queued' &&
        !hasUnsettledRequestForSource(requestSourceKey(record.request)),
    );
  if (!firstPendingRecord) {
    for (const key of pendingKeys) {
      queuedKeys.delete(key);
      const record = records.get(key);
      if (record?.snapshot.status === 'queued') parkForTransportCapacity(record);
    }
    pruneRecords();
    return;
  }
  const batchSource = requestSourceKey(firstPendingRecord.request);
  for (const key of pendingKeys) {
    queuedKeys.delete(key);
    const record = records.get(key);
    if (!record || record.snapshot.status !== 'queued') continue;
    if (requestSourceKey(record.request) !== batchSource) {
      queuedKeys.add(key);
      continue;
    }
    publish(record, { status: 'loading' });
    batch.push({ record, attempt: (record.loadAttempt += 1) });
    if (batch.length === BATCH_SIZE) break;
  }
  if (batch.length === 0) return;

  let ipcRequest: Promise<PluginMarketLocalIconResult[]>;
  try {
    ipcRequest = window.electronAPI.pluginMarket.localIcons(
      batch.map(({ record }) => record.request),
    );
  } catch {
    for (const { record, attempt } of batch) {
      if (record.loadAttempt === attempt) markRetryable(record);
    }
    if (queuedKeys.size > 0) scheduleFlush();
    return;
  }

  // Raw Electron invoke 是不可取消的 transport 资源:全局最多 2 个,且同一不透明
  // 来源身份最多占 1 个槽;同名但不同来源不会被旧请求误阻塞。
  trackUnsettledLocalIconRequest(ipcRequest, batchSource);
  flushInFlight = true;
  try {
    const results = await localIconsWithinTimeoutFromPromise(ipcRequest);
    const byKey = new Map(results.map((result) => [requestKey(result), result]));
    for (const { record, attempt } of batch) {
      if (record.loadAttempt !== attempt) continue;
      const result = byKey.get(requestKey(record.request));
      if (result) applyResult(record, result);
      else markRetryable(record);
    }
  } catch {
    for (const { record, attempt } of batch) {
      if (record.loadAttempt === attempt) markRetryable(record);
    }
  } finally {
    // Timeout 只释放逻辑批次(flushInFlight),不会释放不可取消 raw invoke 的 transport
    // 槽位;后者必须等真实 settle,才能维持“底层未完成请求严格 <= 2”的硬上界。
    // 迟到结果由 loadAttempt 隔离,不能覆盖新尝试。
    flushInFlight = false;
    pruneRecords();
    if (queuedKeys.size > 0) scheduleFlush();
  }
}

function subscribe(request: PluginMarketLocalIconRequest | null, listener: () => void): () => void {
  if (!request) return () => undefined;
  const record = recordFor(request);
  record.listeners.add(listener);
  return () => {
    record.listeners.delete(listener);
    pruneRecords();
  };
}

function snapshot(request: PluginMarketLocalIconRequest | null): LocalIconSnapshot {
  return request ? recordFor(request).snapshot : EMPTY_SNAPSHOT;
}

function pin(request: PluginMarketLocalIconRequest): () => void {
  const record = recordFor(request);
  record.pinCount += 1;
  record.lastUsed = Date.now();
  queueRecord(record);
  return () => {
    record.pinCount = Math.max(0, record.pinCount - 1);
    if (record.pinCount === 0 && record.retryTimer !== null) {
      clearTimeout(record.retryTimer);
      record.retryTimer = null;
    }
    evictUnpinnedData();
    pruneRecords();
  };
}

function reportDecodeFailure(request: PluginMarketLocalIconRequest): void {
  const record = recordFor(request);
  markRetryable(record);
}

function reportDecodeSuccess(request: PluginMarketLocalIconRequest): void {
  const record = recordFor(request);
  record.retryCount = 0;
}

export function usePluginMarketIcon(
  item: Pick<PluginMarketItem, 'pluginId' | 'icon' | 'customIconKey' | 'sourceType'>,
  { deferUntilVisible }: { deferUntilVisible: boolean },
) {
  const request = useMemo<PluginMarketLocalIconRequest | null>(
    () =>
      item.sourceType !== 'server' &&
      item.customIconKey &&
      isPluginMarketCustomIconKey(item.customIconKey)
        ? { pluginId: item.pluginId, expectedIconKey: item.customIconKey }
        : null,
    [item.customIconKey, item.pluginId, item.sourceType],
  );
  const [target, setTarget] = useState<HTMLElement | null>(null);
  const [nearViewport, setNearViewport] = useState(
    () => !deferUntilVisible || typeof IntersectionObserver === 'undefined',
  );

  useEffect(() => {
    if (!request || !deferUntilVisible) {
      setNearViewport(true);
      return;
    }
    if (!target || typeof IntersectionObserver === 'undefined') {
      setNearViewport(typeof IntersectionObserver === 'undefined');
      return;
    }
    setNearViewport(false);
    const observer = new IntersectionObserver(
      (entries) => setNearViewport(entries.some((entry) => entry.isIntersecting)),
      { rootMargin: '240px' },
    );
    observer.observe(target);
    return () => observer.disconnect();
  }, [deferUntilVisible, request, target]);

  const subscribeToRequest = useCallback(
    (listener: () => void) => subscribe(request, listener),
    [request],
  );
  const getSnapshot = useCallback(() => snapshot(request), [request]);
  const current = useSyncExternalStore(subscribeToRequest, getSnapshot, getSnapshot);

  useEffect(() => {
    if (!request || !nearViewport) return;
    return pin(request);
  }, [nearViewport, request]);

  const onIconLoadError = useCallback(
    (fallback?: () => void) => {
      if (request) reportDecodeFailure(request);
      else fallback?.();
    },
    [request],
  );
  const onIconLoad = useCallback(() => {
    if (request) reportDecodeSuccess(request);
  }, [request]);

  return {
    containerRef: setTarget,
    iconDataUrl:
      request && current.status === 'loaded'
        ? current.dataUrl
        : request
          ? undefined
          : item.icon?.url,
    onIconLoad,
    onIconLoadError,
  };
}

export function __resetPluginMarketIconStoreForTest(): void {
  for (const record of records.values()) {
    if (record.retryTimer !== null) clearTimeout(record.retryTimer);
  }
  records.clear();
  queuedKeys.clear();
  transportBlockedKeys.clear();
  unsettledLocalIconRequests.clear();

  flushScheduled = false;
  flushInFlight = false;
  pruneScheduled = false;
  totalDataSize = 0;
}

export function __pluginMarketIconStoreStatsForTest(): {
  records: number;
  loadedDataSize: number;
  unsettledRequests: number;
} {
  return {
    records: records.size,
    loadedDataSize: totalDataSize,
    unsettledRequests: unsettledLocalIconRequests.size,
  };
}