paseo-plugin-zcode-provider 0.0.0-stage → 0.2.0

package/server/vendor/zcode/packages/rpc/src/channelClient.ts

@@ -0,0 +1,275 @@
+import { VSBuffer } from "./buffer.js";
+import { CancellationToken, Event, Emitter, type IDisposable } from "./foundation.js";
+import { BufferReader, BufferWriter, deserialize, serialize } from "./serialization.js";
+import type { IMessagePassingProtocol } from "./protocol.js";
+import {
+  type IChannel,
+  type IChannelClient,
+  type IHandler,
+  type IRawResponse,
+  RequestType,
+  ResponseType,
+} from "./channels.shared.js";
+
+enum State {
+  Uninitialized,
+  Idle,
+}
+
+export class ChannelClient implements IChannelClient, IDisposable {
+  private state = State.Uninitialized;
+  private isDisposed = false;
+  private activeRequests = new Set<IDisposable>();
+  private handlers = new Map<number, IHandler>();
+  // Promise 请求和事件监听共用 handlers，但只有前者需要在连接终结时 reject。
+  // 单独维护 reject map，避免 dispose 把事件订阅误当成挂起的 RPC 请求。
+  private pendingRejections = new Map<number, (error: Error) => void>();
+  private lastRequestId = 0;
+  private protocolListener: IDisposable | null;
+
+  private readonly _onDidInitialize = new Emitter<void>();
+  readonly onDidInitialize = this._onDidInitialize.event;
+
+  constructor(private protocol: IMessagePassingProtocol) {
+    this.protocolListener = this.protocol.onMessage((msg) => this.onBuffer(msg));
+  }
+
+  getChannel<T extends IChannel>(channelName: string): T {
+    return {
+      call: (command: string, arg?: any, cancellationToken?: CancellationToken) => {
+        if (this.isDisposed) {
+          return Promise.reject(new Error("ChannelClient is disposed"));
+        }
+        return this.requestPromise(channelName, command, arg, cancellationToken);
+      },
+      listen: (event: string, arg?: any) => {
+        if (this.isDisposed) {
+          return Event.None;
+        }
+        return this.requestEvent(channelName, event, arg);
+      },
+    } as T;
+  }
+
+  private requestPromise(
+    channelName: string,
+    name: string,
+    arg?: any,
+    cancellationToken = CancellationToken.None,
+  ): Promise<any> {
+    const id = this.lastRequestId++;
+
+    if (cancellationToken.isCancellationRequested) {
+      return Promise.reject(new Error("Cancelled"));
+    }
+
+    let disposable: IDisposable | undefined;
+    const result = new Promise<any>((resolve, reject) => {
+      this.pendingRejections.set(id, reject);
+      const doRequest = () => {
+        // dispose/cancel 可能发生在 Initialize 之前；此时不能再把已经 rejected
+        // 的请求发送到新连接或已终结的传输上。
+        if (this.isDisposed || !this.pendingRejections.has(id)) {
+          return;
+        }
+
+        const handler: IHandler = (response) => {
+          switch (response.type) {
+            case ResponseType.PromiseSuccess:
+              this.handlers.delete(id);
+              this.pendingRejections.delete(id);
+              resolve(response.data);
+              return;
+            case ResponseType.PromiseError: {
+              this.handlers.delete(id);
+              this.pendingRejections.delete(id);
+              const error = new Error(response.data.message) as Error & Record<string, unknown>;
+              error.name = response.data.name;
+              if (response.data.stack) {
+                error.stack = response.data.stack.join("\n");
+              }
+              const passthroughKeys = [
+                "code",
+                "kind",
+                "status",
+                "retryAfterMs",
+                "data",
+                "detail",
+                "details",
+                "taskId",
+                "traceId",
+              ] as const;
+              for (const key of passthroughKeys) {
+                const value = response.data[key];
+                if (value !== undefined) {
+                  error[key] = value;
+                }
+              }
+              reject(error);
+              return;
+            }
+            case ResponseType.PromiseErrorObj:
+              this.handlers.delete(id);
+              this.pendingRejections.delete(id);
+              reject(response.data);
+              return;
+          }
+        };
+
+        this.handlers.set(id, handler);
+        this.sendRequest(RequestType.Promise, id, channelName, name, arg);
+      };
+
+      if (this.state === State.Idle) {
+        doRequest();
+      } else {
+        this.whenInitialized().then(doRequest);
+      }
+
+      disposable = cancellationToken.onCancellationRequested(() => {
+        if (!this.pendingRejections.has(id)) {
+          return;
+        }
+        this.sendCancelOrDispose(RequestType.PromiseCancel, id);
+        this.handlers.delete(id);
+        this.pendingRejections.delete(id);
+        reject(new Error("Cancelled"));
+      });
+      this.activeRequests.add(disposable);
+    });
+
+    return result.finally(() => {
+      disposable?.dispose();
+      if (disposable) {
+        this.activeRequests.delete(disposable);
+      }
+    });
+  }
+
+  private requestEvent(channelName: string, name: string, arg?: any): Event<any> {
+    const id = this.lastRequestId++;
+    const emitter = new Emitter<any>({
+      onWillAddFirstListener: () => {
+        const doRequest = () => {
+          this.activeRequests.add(emitter);
+          this.sendRequest(RequestType.EventListen, id, channelName, name, arg);
+        };
+
+        if (this.state === State.Idle) {
+          doRequest();
+        } else {
+          this.whenInitialized().then(doRequest);
+        }
+      },
+      onDidRemoveLastListener: () => {
+        this.activeRequests.delete(emitter);
+        this.sendCancelOrDispose(RequestType.EventDispose, id);
+        this.handlers.delete(id);
+      },
+    });
+
+    this.handlers.set(id, (response) => {
+      emitter.fire((response as { data: any }).data);
+    });
+
+    return emitter.event;
+  }
+
+  private sendRequest(
+    type: RequestType,
+    id: number,
+    channelName: string,
+    name: string,
+    arg?: any,
+  ): void {
+    const writer = new BufferWriter();
+    serialize(writer, [type, id, channelName, name]);
+    serialize(writer, arg);
+    try {
+      this.protocol.send(writer.buffer);
+    } catch {
+      /* noop */
+    }
+  }
+
+  private sendCancelOrDispose(
+    type: RequestType.PromiseCancel | RequestType.EventDispose,
+    id: number,
+  ): void {
+    const writer = new BufferWriter();
+    serialize(writer, [type, id]);
+    serialize(writer, undefined);
+    try {
+      this.protocol.send(writer.buffer);
+    } catch {
+      /* noop */
+    }
+  }
+
+  private onBuffer(message: VSBuffer): void {
+    const reader = new BufferReader(message);
+    const header = deserialize(reader);
+    const body = deserialize(reader);
+    const type = header[0] as ResponseType;
+
+    switch (type) {
+      case ResponseType.Initialize:
+        this.onResponse({ type: ResponseType.Initialize });
+        return;
+      case ResponseType.PromiseSuccess:
+      case ResponseType.PromiseError:
+      case ResponseType.EventFire:
+      case ResponseType.PromiseErrorObj:
+        this.onResponse({
+          type,
+          id: header[1],
+          data: body,
+        } as IRawResponse);
+        return;
+    }
+  }
+
+  private onResponse(response: IRawResponse): void {
+    if (response.type === ResponseType.Initialize) {
+      this.state = State.Idle;
+      this._onDidInitialize.fire();
+      return;
+    }
+
+    this.handlers.get(response.id)?.(response);
+  }
+
+  private whenInitialized(): Promise<void> {
+    if (this.state === State.Idle) {
+      return Promise.resolve();
+    }
+    return Event.toPromise(this.onDidInitialize);
+  }
+
+  dispose(reason?: Error): void {
+    if (this.isDisposed) {
+      return;
+    }
+    this.isDisposed = true;
+    this.protocolListener?.dispose();
+    this.protocolListener = null;
+
+    const rejection = reason ?? new Error("ChannelClient disposed");
+    if (!reason) {
+      rejection.name = "ConnectionClosed";
+    }
+    // 传输已终结时，所有已发出以及排队等待 Initialize 的 Promise 请求都必须
+    // fail-closed。否则上层的 in-flight 去重 Promise 会永久占用 workspace key。
+    for (const [id, reject] of this.pendingRejections) {
+      this.pendingRejections.delete(id);
+      this.handlers.delete(id);
+      reject(rejection);
+    }
+    for (const disposable of this.activeRequests) {
+      disposable.dispose();
+    }
+    this.activeRequests.clear();
+    this.pendingRejections.clear();
+    this._onDidInitialize.dispose();
+  }
+}

package/server/vendor/zcode/packages/rpc/src/channelServer.ts

@@ -0,0 +1,283 @@
+import { VSBuffer } from "./buffer.js";
+import { type IDisposable, CancellationTokenSource, toDisposable } from "./foundation.js";
+import { BufferReader, BufferWriter, deserialize, serialize } from "./serialization.js";
+import type { IMessagePassingProtocol } from "./protocol.js";
+import {
+  type IChannelServer,
+  type IRawResponse,
+  type IServerChannel,
+  RequestType,
+  ResponseType,
+} from "./channels.shared.js";
+
+export class ChannelServer<TContext = string> implements IChannelServer<TContext>, IDisposable {
+  private channels = new Map<string, IServerChannel<TContext>>();
+  private activeRequests = new Map<number, IDisposable>();
+  private pendingRequests = new Map<
+    string,
+    { request: any; timer: ReturnType<typeof setTimeout> }[]
+  >();
+  private protocolListener: IDisposable | null;
+
+  constructor(
+    private protocol: IMessagePassingProtocol,
+    private ctx: TContext,
+    private timeoutDelay = 1000,
+    private deferInit = false,
+  ) {
+    this.protocolListener = this.protocol.onMessage((msg) => this.onRawMessage(msg));
+    if (!this.deferInit) {
+      this.sendResponse({ type: ResponseType.Initialize });
+    }
+  }
+
+  ready(): void {
+    this.sendResponse({ type: ResponseType.Initialize });
+  }
+
+  registerChannel(channelName: string, channel: IServerChannel<TContext>): void {
+    this.channels.set(channelName, channel);
+    setTimeout(() => this.flushPendingRequests(channelName), 0);
+  }
+
+  private sendResponse(response: IRawResponse): void {
+    switch (response.type) {
+      case ResponseType.Initialize:
+        this.send([response.type]);
+        return;
+      case ResponseType.PromiseSuccess:
+      case ResponseType.PromiseError:
+      case ResponseType.EventFire:
+      case ResponseType.PromiseErrorObj:
+        this.send([response.type, response.id], response.data);
+        return;
+    }
+  }
+
+  private send(header: any, body: any = undefined): void {
+    const writer = new BufferWriter();
+    serialize(writer, header);
+    serialize(writer, body);
+    try {
+      this.protocol.send(writer.buffer);
+    } catch {
+      /* noop */
+    }
+  }
+
+  private onRawMessage(message: VSBuffer): void {
+    const reader = new BufferReader(message);
+    const header = deserialize(reader);
+    const body = deserialize(reader);
+    const type = header[0] as RequestType;
+
+    switch (type) {
+      case RequestType.Promise:
+        this.onPromise({
+          type,
+          id: header[1],
+          channelName: header[2],
+          name: header[3],
+          arg: body,
+        });
+        return;
+      case RequestType.EventListen:
+        this.onEventListen({
+          type,
+          id: header[1],
+          channelName: header[2],
+          name: header[3],
+          arg: body,
+        });
+        return;
+      case RequestType.PromiseCancel:
+      case RequestType.EventDispose:
+        this.disposeActiveRequest(header[1]);
+        return;
+    }
+  }
+
+  private onPromise(request: {
+    type: RequestType.Promise;
+    id: number;
+    channelName: string;
+    name: string;
+    arg: any;
+  }): void {
+    const channel = this.channels.get(request.channelName);
+    if (!channel) {
+      this.collectPendingRequest(request);
+      return;
+    }
+
+    const cts = new CancellationTokenSource();
+    let promise: Promise<any>;
+
+    try {
+      promise = channel.call(this.ctx, request.name, request.arg, cts.token);
+    } catch (error) {
+      promise = Promise.reject(error);
+    }
+
+    const disposable = toDisposable(() => cts.cancel());
+    this.activeRequests.set(request.id, disposable);
+
+    promise
+      .then(
+        (data) => {
+          this.sendResponse({
+            id: request.id,
+            data,
+            type: ResponseType.PromiseSuccess,
+          });
+        },
+        (error) => {
+          if (error instanceof Error) {
+            const rpcErrorPayload: {
+              message: string;
+              name: string;
+              stack: string[] | undefined;
+              code?: unknown;
+              kind?: unknown;
+              status?: unknown;
+              retryAfterMs?: unknown;
+              data?: unknown;
+              detail?: unknown;
+              details?: unknown;
+              taskId?: unknown;
+              traceId?: unknown;
+            } = {
+              message: error.message,
+              name: error.name,
+              stack: error.stack ? error.stack.split("\n") : undefined,
+            };
+            const errorRecord = error as Error & Record<string, unknown>;
+            const passthroughKeys = [
+              "code",
+              "kind",
+              "status",
+              "retryAfterMs",
+              "data",
+              "detail",
+              "details",
+              "taskId",
+              "traceId",
+            ] as const;
+            for (const key of passthroughKeys) {
+              const value = errorRecord[key];
+              if (value !== undefined) {
+                rpcErrorPayload[key] = value;
+              }
+            }
+            this.sendResponse({
+              id: request.id,
+              data: rpcErrorPayload,
+              type: ResponseType.PromiseError,
+            });
+            return;
+          }
+
+          this.sendResponse({
+            id: request.id,
+            data: error,
+            type: ResponseType.PromiseErrorObj,
+          });
+        },
+      )
+      .finally(() => {
+        disposable.dispose();
+        this.activeRequests.delete(request.id);
+      });
+  }
+
+  private onEventListen(request: {
+    type: RequestType.EventListen;
+    id: number;
+    channelName: string;
+    name: string;
+    arg: any;
+  }): void {
+    const channel = this.channels.get(request.channelName);
+    if (!channel) {
+      this.collectPendingRequest(request);
+      return;
+    }
+
+    const disposable = channel.listen(
+      this.ctx,
+      request.name,
+      request.arg,
+    )((data) => {
+      this.sendResponse({
+        id: request.id,
+        data,
+        type: ResponseType.EventFire,
+      });
+    });
+    this.activeRequests.set(request.id, disposable);
+  }
+
+  private disposeActiveRequest(id: number): void {
+    const disposable = this.activeRequests.get(id);
+    if (!disposable) {
+      return;
+    }
+    disposable.dispose();
+    this.activeRequests.delete(id);
+  }
+
+  private collectPendingRequest(request: any): void {
+    const pendingRequests = this.pendingRequests.get(request.channelName) ?? [];
+    if (pendingRequests.length === 0) {
+      this.pendingRequests.set(request.channelName, pendingRequests);
+    }
+
+    const timer = setTimeout(() => {
+      console.error(`Unknown channel: ${request.channelName}`);
+      if (request.type !== RequestType.Promise) {
+        return;
+      }
+
+      this.sendResponse({
+        id: request.id,
+        data: {
+          name: "Unknown channel",
+          message: `Channel name '${request.channelName}' timed out after ${this.timeoutDelay}ms`,
+          stack: undefined,
+        },
+        type: ResponseType.PromiseError,
+      });
+    }, this.timeoutDelay);
+
+    pendingRequests.push({ request, timer });
+  }
+
+  private flushPendingRequests(channelName: string): void {
+    const requests = this.pendingRequests.get(channelName);
+    if (!requests) {
+      return;
+    }
+
+    for (const { request, timer } of requests) {
+      clearTimeout(timer);
+      switch (request.type) {
+        case RequestType.Promise:
+          this.onPromise(request);
+          break;
+        case RequestType.EventListen:
+          this.onEventListen(request);
+          break;
+      }
+    }
+    this.pendingRequests.delete(channelName);
+  }
+
+  dispose(): void {
+    this.protocolListener?.dispose();
+    this.protocolListener = null;
+    for (const disposable of this.activeRequests.values()) {
+      disposable.dispose();
+    }
+    this.activeRequests.clear();
+  }
+}

package/server/vendor/zcode/packages/rpc/src/channels.shared.ts

@@ -0,0 +1,66 @@
+import type { CancellationToken, Event } from "./foundation.js";
+
+export interface IChannel {
+  call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<T>;
+  listen<T>(event: string, arg?: any): Event<T>;
+}
+
+export interface IServerChannel<TContext = string> {
+  call<T>(
+    ctx: TContext,
+    command: string,
+    arg?: any,
+    cancellationToken?: CancellationToken,
+  ): Promise<T>;
+  listen<T>(ctx: TContext, event: string, arg?: any): Event<T>;
+}
+
+export const enum RequestType {
+  Promise = 100,
+  PromiseCancel = 101,
+  EventListen = 102,
+  EventDispose = 103,
+}
+
+export const enum ResponseType {
+  Initialize = 200,
+  PromiseSuccess = 201,
+  PromiseError = 202,
+  PromiseErrorObj = 203,
+  EventFire = 204,
+}
+
+export type IRawResponse =
+  | { type: ResponseType.Initialize }
+  | { type: ResponseType.PromiseSuccess; id: number; data: any }
+  | {
+      type: ResponseType.PromiseError;
+      id: number;
+      data: {
+        message: string;
+        name: string;
+        stack: string[] | undefined;
+        code?: unknown;
+        kind?: unknown;
+        status?: unknown;
+        retryAfterMs?: unknown;
+        data?: unknown;
+        detail?: unknown;
+        details?: unknown;
+        taskId?: unknown;
+        traceId?: unknown;
+      };
+    }
+  | { type: ResponseType.PromiseErrorObj; id: number; data: any }
+  | { type: ResponseType.EventFire; id: number; data: any };
+
+export type IHandler = (response: IRawResponse) => void;
+
+export interface IChannelServer<TContext = string> {
+  registerChannel(channelName: string, channel: IServerChannel<TContext>): void;
+  ready?(): void;
+}
+
+export interface IChannelClient {
+  getChannel<T extends IChannel>(channelName: string): T;
+}

package/server/vendor/zcode/packages/rpc/src/channels.ts

@@ -0,0 +1,4 @@
+export * from "./channels.shared.js";
+export { ChannelServer } from "./channelServer.js";
+export { ChannelClient } from "./channelClient.js";
+export { getDelayedChannel } from "./delayedChannel.js";

package/server/vendor/zcode/packages/rpc/src/delayedChannel.ts

@@ -0,0 +1,17 @@
+import { type CancellationToken, Event, Relay } from "./foundation.js";
+import type { IChannel } from "./channels.shared.js";
+
+export function getDelayedChannel<T extends IChannel>(promise: Promise<T>): T {
+  return {
+    call(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<any> {
+      return promise.then((channel) => channel.call(command, arg, cancellationToken));
+    },
+    listen(event: string, arg?: any): Event<any> {
+      const relay = new Relay<any>();
+      promise.then((channel) => {
+        relay.input = channel.listen(event, arg);
+      });
+      return relay.event;
+    },
+  } as T;
+}