[Init] Initial commit - NetMesh terminal manager

application/state/pluginTerminalProviderRegistry.ts

@@ -0,0 +1,319 @@
+export interface PluginTerminalProviderBridge {
+  listPluginTerminalProviders(options: NetcattyTerminalProviderQuery): Promise<ReadonlyArray<NetcattyTerminalProviderContribution>>;
+  providePluginTerminal(request: NetcattyTerminalProviderRequest): Promise<ReadonlyArray<NetcattyTerminalProviderResult>>;
+  cancelPluginTerminalRequest(requestId: string): Promise<boolean>;
+  publishPluginTerminalSessionEvent(event: NetcattyTerminalSessionEvent): Promise<ReadonlyArray<{ pluginId: string; delivered: boolean }>>;
+  onPluginContributionsChanged?(callback: () => void): () => void;
+}
+
+export interface PluginTerminalProviderResponse {
+  readonly requestId: string;
+  readonly stale: boolean;
+  readonly results: ReadonlyArray<NetcattyTerminalProviderResult>;
+}
+
+export interface PluginTerminalProviderRequestOptions {
+  readonly signal?: AbortSignal;
+}
+
+function freezeValue<T>(value: T): Readonly<T> {
+  const clone = structuredClone(value);
+  const freeze = (item: unknown): void => {
+    if (!item || typeof item !== 'object' || Object.isFrozen(item)) return;
+    for (const child of Array.isArray(item) ? item : Object.values(item)) freeze(child);
+    Object.freeze(item);
+  };
+  freeze(clone);
+  return clone as Readonly<T>;
+}
+
+function requestKey(sessionId: string, kind: NetcattyTerminalProviderKind, supersessionKey: string): string {
+  return `${sessionId}\0${kind}\0${supersessionKey}`;
+}
+
+function createRequestId(): string {
+  return `terminal-${crypto.randomUUID()}`;
+}
+
+function mergeLifecycleSessionSnapshot(
+  previous: NetcattyTerminalSessionSnapshot | undefined,
+  event: NetcattyTerminalSessionEvent,
+): Readonly<NetcattyTerminalSessionSnapshot> {
+  const session: NetcattyTerminalSessionSnapshot = { ...(previous ?? {}), ...event.session };
+  if (event.type === 'disconnected' || event.type === 'reconnected') {
+    if (!Object.hasOwn(event.session, 'cwd')) delete session.cwd;
+    if (!Object.hasOwn(event.session, 'title')) delete session.title;
+    if (!Object.hasOwn(event.session, 'alternateScreen')) delete session.alternateScreen;
+  }
+  if (event.type === 'cwdChanged' && !Object.hasOwn(event.session, 'cwd')) delete session.cwd;
+  if (event.type === 'titleChanged' && !Object.hasOwn(event.session, 'title')) delete session.title;
+  return freezeValue(session);
+}
+
+export class PluginTerminalProviderRegistry {
+  readonly #bridge: PluginTerminalProviderBridge;
+  readonly #activeRequests = new Map<string, string>();
+  readonly #sessionSnapshots = new Map<string, NetcattyTerminalSessionSnapshot>();
+  readonly #providerListeners = new Set<() => void>();
+  readonly #providerListCache = new Map<string, ReadonlyArray<NetcattyTerminalProviderContribution>>();
+  readonly #pendingProviderLists = new Map<string, Promise<ReadonlyArray<NetcattyTerminalProviderContribution>>>();
+  readonly #disposeContributionListener: (() => void) | undefined;
+  #providerListGeneration = 0;
+  #bridgeAvailability: 'unknown' | 'available' | 'unavailable' = 'unknown';
+  #disposed = false;
+
+  constructor(bridge: PluginTerminalProviderBridge) {
+    this.#bridge = bridge;
+    this.#disposeContributionListener = bridge.onPluginContributionsChanged?.(() => {
+      this.#providerListGeneration += 1;
+      this.#bridgeAvailability = 'unknown';
+      this.#providerListCache.clear();
+      this.#pendingProviderLists.clear();
+      for (const requestId of this.#activeRequests.values()) {
+        void this.#bridge.cancelPluginTerminalRequest(requestId).catch(() => false);
+      }
+      this.#activeRequests.clear();
+      for (const listener of [...this.#providerListeners]) {
+        try { listener(); } catch { /* isolate application listeners */ }
+      }
+    });
+  }
+
+  onDidChangeProviders(listener: () => void): () => void {
+    if (this.#disposed) return () => {};
+    this.#providerListeners.add(listener);
+    return () => this.#providerListeners.delete(listener);
+  }
+
+  async listProviders(query: NetcattyTerminalProviderQuery): Promise<ReadonlyArray<NetcattyTerminalProviderContribution>> {
+    if (this.#disposed) return Object.freeze([]);
+    if (this.#bridgeAvailability === 'unavailable') return Object.freeze([]);
+    const key = JSON.stringify(query);
+    const cached = this.#providerListCache.get(key);
+    if (cached) return cached;
+    const pending = this.#pendingProviderLists.get(key);
+    if (pending) return pending;
+    const generation = this.#providerListGeneration;
+    const request = (async () => {
+      try {
+        const providers = freezeValue(await this.#bridge.listPluginTerminalProviders(query));
+        if (generation === this.#providerListGeneration) {
+          if (this.#bridgeAvailability !== 'unavailable') this.#bridgeAvailability = 'available';
+          this.#providerListCache.set(key, providers);
+        }
+        return providers;
+      } catch (error) {
+        if (generation === this.#providerListGeneration) {
+          this.#bridgeAvailability = 'unavailable';
+          this.#providerListCache.clear();
+        }
+        throw error;
+      } finally {
+        if (this.#pendingProviderLists.get(key) === request) this.#pendingProviderLists.delete(key);
+      }
+    })();
+    this.#pendingProviderLists.set(key, request);
+    return request;
+  }
+
+  async request(
+    request: Omit<NetcattyTerminalProviderRequest, 'requestId'> & { supersessionKey?: string },
+    options: PluginTerminalProviderRequestOptions = {},
+  ): Promise<PluginTerminalProviderResponse> {
+    if (this.#disposed || options.signal?.aborted) {
+      return Object.freeze({ requestId: '', stale: true, results: Object.freeze([]) });
+    }
+    const { supersessionKey: rawSupersessionKey, ...providerRequest } = request;
+    const supersessionKey = typeof rawSupersessionKey === 'string'
+      && rawSupersessionKey.length > 0
+      && rawSupersessionKey.length <= 128
+      ? rawSupersessionKey
+      : 'default';
+    const previousSession = this.#sessionSnapshots.get(request.session.sessionId);
+    const session = freezeValue({ ...(previousSession ?? {}), ...request.session });
+    this.#sessionSnapshots.set(session.sessionId, session);
+    const key = requestKey(session.sessionId, request.kind, supersessionKey);
+    const previousRequestId = this.#activeRequests.get(key);
+    if (previousRequestId) void this.#bridge.cancelPluginTerminalRequest(previousRequestId).catch(() => false);
+    const requestId = createRequestId();
+    this.#activeRequests.set(key, requestId);
+    let bridgeRequestStarted = false;
+    let aborted = false;
+    let resolveAborted: (() => void) | undefined;
+    const abortedRequest = new Promise<{
+      readonly status: 'aborted';
+    }>((resolve) => {
+      resolveAborted = () => resolve({ status: 'aborted' });
+    });
+    const onAbort = () => {
+      if (aborted) return;
+      aborted = true;
+      if (this.#activeRequests.get(key) === requestId) this.#activeRequests.delete(key);
+      if (bridgeRequestStarted) {
+        void this.#bridge.cancelPluginTerminalRequest(requestId).catch(() => false);
+      }
+      resolveAborted?.();
+    };
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+      if (options.signal?.aborted) onAbort();
+      if (aborted) {
+        return Object.freeze({ requestId, stale: true, results: Object.freeze([]) });
+      }
+      bridgeRequestStarted = true;
+      let bridgeResponse: Promise<ReadonlyArray<NetcattyTerminalProviderResult>>;
+      try {
+        bridgeResponse = this.#bridge.providePluginTerminal({
+          ...providerRequest,
+          session,
+          requestId,
+        });
+      } catch (error) {
+        bridgeResponse = Promise.reject(error);
+      }
+      const bridgeRequest = bridgeResponse
+        .then(
+          (results) => ({ status: 'fulfilled' as const, results }),
+          (error: unknown) => ({ status: 'rejected' as const, error }),
+        );
+      const outcome = options.signal
+        ? await Promise.race([bridgeRequest, abortedRequest])
+        : await bridgeRequest;
+      if (outcome.status === 'aborted') {
+        return Object.freeze({ requestId, stale: true, results: Object.freeze([]) });
+      }
+      if (outcome.status === 'rejected') {
+        const stale = this.#disposed || this.#activeRequests.get(key) !== requestId;
+        if (stale) return Object.freeze({ requestId, stale: true, results: Object.freeze([]) });
+        throw outcome.error;
+      }
+      const results = freezeValue(outcome.results);
+      const stale = this.#disposed || this.#activeRequests.get(key) !== requestId;
+      return Object.freeze({
+        requestId,
+        stale,
+        results: stale ? Object.freeze([]) : results,
+      });
+    } catch (error) {
+      const stale = this.#disposed || this.#activeRequests.get(key) !== requestId;
+      if (stale) return Object.freeze({ requestId, stale: true, results: Object.freeze([]) });
+      throw error;
+    } finally {
+      options.signal?.removeEventListener('abort', onAbort);
+      if (this.#activeRequests.get(key) === requestId) this.#activeRequests.delete(key);
+    }
+  }
+
+  async publishSessionEvent(event: NetcattyTerminalSessionEvent): Promise<void> {
+    if (this.#disposed) return;
+    const previous = this.#sessionSnapshots.get(event.session.sessionId);
+    const session = mergeLifecycleSessionSnapshot(previous, event);
+    if (event.type === 'disposed') this.#sessionSnapshots.delete(session.sessionId);
+    else this.#sessionSnapshots.set(session.sessionId, session);
+    if (this.#bridgeAvailability === 'unavailable') return;
+    try {
+      await this.#bridge.publishPluginTerminalSessionEvent(freezeValue({ ...event, session }));
+      this.#bridgeAvailability = 'available';
+    } catch (error) {
+      this.#bridgeAvailability = 'unavailable';
+      throw error;
+    }
+  }
+
+  cancelSession(sessionId: string): void {
+    this.#sessionSnapshots.delete(sessionId);
+    for (const [key, requestId] of [...this.#activeRequests]) {
+      if (!key.startsWith(`${sessionId}\0`)) continue;
+      this.#activeRequests.delete(key);
+      void this.#bridge.cancelPluginTerminalRequest(requestId).catch(() => false);
+    }
+  }
+
+  dispose(): void {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.#providerListGeneration += 1;
+    for (const requestId of this.#activeRequests.values()) {
+      void this.#bridge.cancelPluginTerminalRequest(requestId).catch(() => false);
+    }
+    this.#activeRequests.clear();
+    this.#sessionSnapshots.clear();
+    this.#providerListeners.clear();
+    this.#providerListCache.clear();
+    this.#pendingProviderLists.clear();
+    this.#disposeContributionListener?.();
+  }
+}
+
+export async function collectPluginTerminalProviderKinds(
+  registry: PluginTerminalProviderRegistry | null,
+  kinds: readonly NetcattyTerminalProviderKind[],
+): Promise<ReadonlySet<NetcattyTerminalProviderKind>> {
+  if (!registry) return new Set();
+  try {
+    const enumerations = await Promise.all(kinds.map(async (kind) => ({
+      kind,
+      providers: await registry.listProviders({ kind }),
+    })));
+    return new Set(enumerations
+      .filter((entry) => entry.providers.length > 0)
+      .map((entry) => entry.kind));
+  } catch {
+    return new Set();
+  }
+}
+
+export function isPluginTerminalProviderKindAvailable(
+  kinds: ReadonlySet<NetcattyTerminalProviderKind> | null,
+  kind: NetcattyTerminalProviderKind,
+): boolean {
+  return kinds?.has(kind) ?? false;
+}
+
+export class PluginTerminalProviderAvailability {
+  #generation = 0;
+  #kinds: ReadonlySet<NetcattyTerminalProviderKind> | null = null;
+
+  async refresh(
+    registry: PluginTerminalProviderRegistry | null,
+    kinds: readonly NetcattyTerminalProviderKind[],
+  ): Promise<boolean> {
+    const generation = ++this.#generation;
+    const next = await collectPluginTerminalProviderKinds(registry, kinds);
+    if (generation !== this.#generation) return false;
+    this.#kinds = next;
+    return true;
+  }
+
+  has(kind: NetcattyTerminalProviderKind): boolean {
+    return isPluginTerminalProviderKindAvailable(this.#kinds, kind);
+  }
+}
+
+export function createWindowPluginTerminalProviderRegistry(
+  bridge: NetcattyBridge | undefined = typeof window === 'undefined' ? undefined : netcattyBridge.get(),
+): PluginTerminalProviderRegistry | null {
+  if (!bridge?.listPluginTerminalProviders
+    || !bridge.providePluginTerminal
+    || !bridge.cancelPluginTerminalRequest
+    || !bridge.publishPluginTerminalSessionEvent) return null;
+  return new PluginTerminalProviderRegistry({
+    listPluginTerminalProviders: (options) => bridge.listPluginTerminalProviders!(options),
+    providePluginTerminal: (request) => bridge.providePluginTerminal!(request),
+    cancelPluginTerminalRequest: (requestId) => bridge.cancelPluginTerminalRequest!(requestId),
+    publishPluginTerminalSessionEvent: (event) => bridge.publishPluginTerminalSessionEvent!(event),
+    onPluginContributionsChanged: bridge.onPluginContributionsChanged
+      ? (callback) => bridge.onPluginContributionsChanged!(callback)
+      : undefined,
+  });
+}
+
+let windowRegistry: PluginTerminalProviderRegistry | null | undefined;
+
+export function getWindowPluginTerminalProviderRegistry(): PluginTerminalProviderRegistry | null {
+  if (windowRegistry !== undefined) return windowRegistry;
+  if (typeof window === 'undefined') return null;
+  windowRegistry = createWindowPluginTerminalProviderRegistry(netcattyBridge.get());
+  return windowRegistry;
+}
+import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';