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。

4.3 KB
Raw Blame
import { PeerRecoveryScheduler } from './peerRecoveryScheduler';
import {
  fetchDeviceProviders, getDeviceProvidersGen, invalidateDeviceProvidersForRefresh,
  markDeviceFetchEpoch, type DeviceProvidersPayload,
} from './deviceProvidersCache';
import {
  commitAgentCapabilities, evictAgentCapabilitiesForDevice, fetchAgentCapabilities,
  getAgentCapabilitiesGeneration,
} from '@/session/agentCapabilitiesCache';
import { normalizeMobileAgentCapabilities } from '@/session/agentCapabilities';

/** Provider pushes are invalidations, not an instruction to start four more
 * parallel RPCs. Reuse peer recovery's serialized rerun and cancellation rules. */
export function createDeviceCatalogRefresh(options: {
  readProviders(deviceId: string): Promise<DeviceProvidersPayload>;
  readCapabilities(deviceId: string, agent: 'claude-code' | 'codex' | 'pi'): Promise<unknown>;
  connectionEpoch(): number;
  canRead?(deviceId: string): boolean;
}) {
  let disposed = false;
  const queued = new Map<string, ReturnType<typeof setTimeout>>();
  const devices = new Set<string>();
  const invalidate = (id: string) => {
    invalidateDeviceProvidersForRefresh(id);
    evictAgentCapabilitiesForDevice(id);
  };
  const scheduler = new PeerRecoveryScheduler(async (id) => {
    if (disposed) return { retry: false };
    // Keep the invalidation pending without putting requests on an unreadable
    // link. Reuse the scheduler's backoff and cancellation, including dispose.
    if (options.canRead?.(id) === false) return { retry: true };
    const epoch = options.connectionEpoch();
    const providerGeneration = getDeviceProvidersGen(id);
    const generation = getAgentCapabilitiesGeneration(id);
    const read = <T,>(fetcher: () => Promise<T>): Promise<T> => {
      if (disposed || options.canRead?.(id) === false || getAgentCapabilitiesGeneration(id) !== generation) return Promise.reject(new Error('Catalog refresh superseded'));
      return fetcher();
    };
    await Promise.allSettled([
      fetchDeviceProviders(id, () => read(() => options.readProviders(id))).then(() => {
        if (!disposed && getDeviceProvidersGen(id) === providerGeneration) markDeviceFetchEpoch(id, epoch);
      }),
      ...(['claude-code', 'codex', 'pi'] as const).map(async (agent) => {
        const raw = await fetchAgentCapabilities(id, agent, () => read(() => options.readCapabilities(id, agent)));
        const normalized = normalizeMobileAgentCapabilities(raw);
        if (!disposed && normalized) commitAgentCapabilities(id, agent, generation, normalized);
      }),
    ]);
    // A gate may close while a cache read waits for an older in-flight read.
    // Retain that invalidation too; ordinary read errors keep existing policy.
    return { retry: !disposed && options.canRead?.(id) === false };
  });
  return {
    wake(deviceId?: string) {
      if (disposed) return;
      for (const id of deviceId ? [deviceId] : devices) {
        // Resume only accepted work. Do not invalidate a healthy cache or
        // resurrect cancellation. Include running attempts so a recovery
        // racing their settlement cannot leave a newly installed retry asleep.
        if (devices.has(id) && options.canRead?.(id) !== false
          && scheduler.getSnapshot(id).phase !== 'idle') scheduler.request(id);
      }
    },
    notify(id: string) {
      if (disposed) return;
      devices.add(id);
      invalidate(id); // Immediately fence responses already on the wire.
      if (queued.has(id)) return;
      // Separate socket callbacks from the same burst need a bounded batching
      // window, not just a microtask. Further notifications never extend it.
      queued.set(id, setTimeout(() => {
        queued.delete(id);
        if (disposed) return;
        scheduler.request(id);
      }, 50));
    },
    cancel(id: string) {
      clearTimeout(queued.get(id));
      queued.delete(id);
      scheduler.cancel(id);
      if (devices.delete(id)) invalidate(id);
    },
    clear() {
      for (const timer of queued.values()) clearTimeout(timer);
      queued.clear();
      scheduler.clear();
      for (const id of devices) invalidate(id);
      devices.clear();
    },
    dispose() {
      disposed = true;
      for (const timer of queued.values()) clearTimeout(timer);
      queued.clear();
      scheduler.clear();
      for (const id of devices) invalidate(id);
      devices.clear();
    },
  };
}