mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 03:50:52 +00:00
145 lines
6.3 KiB
TypeScript
145 lines
6.3 KiB
TypeScript
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>;
|
|
}
|
|
|
|
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): string {
|
|
return `${sessionId}\0${kind}`;
|
|
}
|
|
|
|
function createRequestId(): string {
|
|
return `terminal-${crypto.randomUUID()}`;
|
|
}
|
|
|
|
export class PluginTerminalProviderRegistry {
|
|
readonly #bridge: PluginTerminalProviderBridge;
|
|
readonly #activeRequests = new Map<string, string>();
|
|
readonly #sessionSnapshots = new Map<string, NetcattyTerminalSessionSnapshot>();
|
|
readonly #providerListeners = new Set<() => void>();
|
|
readonly #disposeContributionListener: (() => void) | undefined;
|
|
#disposed = false;
|
|
|
|
constructor(bridge: PluginTerminalProviderBridge) {
|
|
this.#bridge = bridge;
|
|
this.#disposeContributionListener = bridge.onPluginContributionsChanged?.(() => {
|
|
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([]);
|
|
return freezeValue(await this.#bridge.listPluginTerminalProviders(query));
|
|
}
|
|
|
|
async request(
|
|
request: Omit<NetcattyTerminalProviderRequest, 'requestId'>,
|
|
): Promise<PluginTerminalProviderResponse> {
|
|
if (this.#disposed) return Object.freeze({ requestId: '', stale: true, results: Object.freeze([]) });
|
|
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);
|
|
const previousRequestId = this.#activeRequests.get(key);
|
|
if (previousRequestId) void this.#bridge.cancelPluginTerminalRequest(previousRequestId).catch(() => false);
|
|
const requestId = createRequestId();
|
|
this.#activeRequests.set(key, requestId);
|
|
try {
|
|
const results = freezeValue(await this.#bridge.providePluginTerminal({ ...request, session, requestId }));
|
|
const stale = this.#disposed || this.#activeRequests.get(key) !== requestId;
|
|
return Object.freeze({
|
|
requestId,
|
|
stale,
|
|
results: stale ? Object.freeze([]) : results,
|
|
});
|
|
} finally {
|
|
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 = freezeValue({ ...(previous ?? {}), ...event.session });
|
|
if (event.type === 'disposed') this.#sessionSnapshots.delete(session.sessionId);
|
|
else this.#sessionSnapshots.set(session.sessionId, session);
|
|
await this.#bridge.publishPluginTerminalSessionEvent(freezeValue({ ...event, session }));
|
|
}
|
|
|
|
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;
|
|
for (const requestId of this.#activeRequests.values()) {
|
|
void this.#bridge.cancelPluginTerminalRequest(requestId).catch(() => false);
|
|
}
|
|
this.#activeRequests.clear();
|
|
this.#sessionSnapshots.clear();
|
|
this.#providerListeners.clear();
|
|
this.#disposeContributionListener?.();
|
|
}
|
|
}
|
|
|
|
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';
|