agent-skill-manager 1.20.0 → 1.22.0

package/node_modules/@grpc/grpc-js/src/single-subchannel-channel.ts

@@ -0,0 +1,248 @@
+/*
+ * Copyright 2025 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { AuthContext } from "./auth-context";
+import { CallCredentials } from "./call-credentials";
+import { Call, CallStreamOptions, InterceptingListener, MessageContext, StatusObject } from "./call-interface";
+import { getNextCallNumber } from "./call-number";
+import { Channel } from "./channel";
+import { ChannelOptions } from "./channel-options";
+import { ChannelRef, ChannelzCallTracker, ChannelzChildrenTracker, ChannelzTrace, registerChannelzChannel, unregisterChannelzRef } from "./channelz";
+import { CompressionFilterFactory } from "./compression-filter";
+import { ConnectivityState } from "./connectivity-state";
+import { Propagate, Status } from "./constants";
+import { restrictControlPlaneStatusCode } from "./control-plane-status";
+import { Deadline, getRelativeTimeout } from "./deadline";
+import { FilterStack, FilterStackFactory } from "./filter-stack";
+import { Metadata } from "./metadata";
+import { getDefaultAuthority } from "./resolver";
+import { Subchannel } from "./subchannel";
+import { SubchannelCall } from "./subchannel-call";
+import { GrpcUri, splitHostPort, uriToString } from "./uri-parser";
+
+class SubchannelCallWrapper implements Call {
+  private childCall: SubchannelCall | null = null;
+  private pendingMessage: { context: MessageContext; message: Buffer } | null =
+    null;
+  private readPending = false;
+  private halfClosePending = false;
+  private pendingStatus: StatusObject | null = null;
+  private serviceUrl: string;
+  private filterStack: FilterStack;
+  private readFilterPending = false;
+  private writeFilterPending = false;
+  constructor(private subchannel: Subchannel, private method: string, filterStackFactory: FilterStackFactory, private options: CallStreamOptions, private callNumber: number) {
+    const splitPath: string[] = this.method.split('/');
+    let serviceName = '';
+    /* The standard path format is "/{serviceName}/{methodName}", so if we split
+      * by '/', the first item should be empty and the second should be the
+      * service name */
+    if (splitPath.length >= 2) {
+      serviceName = splitPath[1];
+    }
+    const hostname = splitHostPort(this.options.host)?.host ?? 'localhost';
+    /* Currently, call credentials are only allowed on HTTPS connections, so we
+      * can assume that the scheme is "https" */
+    this.serviceUrl = `https://${hostname}/${serviceName}`;
+    const timeout = getRelativeTimeout(options.deadline);
+    if (timeout !== Infinity) {
+      if (timeout <= 0) {
+        this.cancelWithStatus(Status.DEADLINE_EXCEEDED, 'Deadline exceeded');
+      } else {
+        setTimeout(() => {
+          this.cancelWithStatus(Status.DEADLINE_EXCEEDED, 'Deadline exceeded');
+        }, timeout);
+      }
+    }
+    this.filterStack = filterStackFactory.createFilter();
+  }
+
+  cancelWithStatus(status: Status, details: string): void {
+    if (this.childCall) {
+      this.childCall.cancelWithStatus(status, details);
+    } else {
+      this.pendingStatus = {
+        code: status,
+        details: details,
+        metadata: new Metadata()
+      };
+    }
+
+  }
+  getPeer(): string {
+    return this.childCall?.getPeer() ?? this.subchannel.getAddress();
+  }
+  async start(metadata: Metadata, listener: InterceptingListener): Promise<void> {
+    if (this.pendingStatus) {
+      listener.onReceiveStatus(this.pendingStatus);
+      return;
+    }
+    if (this.subchannel.getConnectivityState() !== ConnectivityState.READY) {
+      listener.onReceiveStatus({
+        code: Status.UNAVAILABLE,
+        details: 'Subchannel not ready',
+        metadata: new Metadata()
+      });
+      return;
+    }
+    const filteredMetadata = await this.filterStack.sendMetadata(Promise.resolve(metadata));
+    let credsMetadata: Metadata;
+    try {
+      credsMetadata = await this.subchannel.getCallCredentials()
+        .generateMetadata({method_name: this.method, service_url: this.serviceUrl});
+    } catch (e) {
+      const error = e as (Error & { code: number });
+      const { code, details } = restrictControlPlaneStatusCode(
+        typeof error.code === 'number' ? error.code : Status.UNKNOWN,
+        `Getting metadata from plugin failed with error: ${error.message}`
+      );
+      listener.onReceiveStatus(
+        {
+          code: code,
+          details: details,
+          metadata: new Metadata(),
+        }
+      );
+      return;
+    }
+    credsMetadata.merge(filteredMetadata);
+    const childListener: InterceptingListener = {
+      onReceiveMetadata: async metadata => {
+        listener.onReceiveMetadata(await this.filterStack.receiveMetadata(metadata));
+      },
+      onReceiveMessage: async message => {
+        this.readFilterPending = true;
+        const filteredMessage = await this.filterStack.receiveMessage(message);
+        this.readFilterPending = false;
+        listener.onReceiveMessage(filteredMessage);
+        if (this.pendingStatus) {
+          listener.onReceiveStatus(this.pendingStatus);
+        }
+      },
+      onReceiveStatus: async status => {
+        const filteredStatus = await this.filterStack.receiveTrailers(status);
+        if (this.readFilterPending) {
+          this.pendingStatus = filteredStatus;
+        } else {
+          listener.onReceiveStatus(filteredStatus);
+        }
+      }
+    }
+    this.childCall = this.subchannel.createCall(credsMetadata, this.options.host, this.method, childListener);
+    if (this.readPending) {
+      this.childCall.startRead();
+    }
+    if (this.pendingMessage) {
+      this.childCall.sendMessageWithContext(this.pendingMessage.context, this.pendingMessage.message);
+    }
+    if (this.halfClosePending && !this.writeFilterPending) {
+      this.childCall.halfClose();
+    }
+  }
+  async sendMessageWithContext(context: MessageContext, message: Buffer): Promise<void> {
+    this.writeFilterPending = true;
+    const filteredMessage = await this.filterStack.sendMessage(Promise.resolve({message: message, flags: context.flags}));
+    this.writeFilterPending = false;
+    if (this.childCall) {
+      this.childCall.sendMessageWithContext(context, filteredMessage.message);
+      if (this.halfClosePending) {
+        this.childCall.halfClose();
+      }
+    } else {
+      this.pendingMessage = { context, message: filteredMessage.message };
+    }
+  }
+  startRead(): void {
+    if (this.childCall) {
+      this.childCall.startRead();
+    } else {
+      this.readPending = true;
+    }
+  }
+  halfClose(): void {
+    if (this.childCall && !this.writeFilterPending) {
+      this.childCall.halfClose();
+    } else {
+      this.halfClosePending = true;
+    }
+  }
+  getCallNumber(): number {
+    return this.callNumber;
+  }
+  setCredentials(credentials: CallCredentials): void {
+    throw new Error("Method not implemented.");
+  }
+  getAuthContext(): AuthContext | null {
+    if (this.childCall) {
+      return this.childCall.getAuthContext();
+    } else {
+      return null;
+    }
+  }
+}
+
+export class SingleSubchannelChannel implements Channel {
+  private channelzRef: ChannelRef;
+  private channelzEnabled = false;
+  private channelzTrace = new ChannelzTrace();
+  private callTracker = new ChannelzCallTracker();
+  private childrenTracker = new ChannelzChildrenTracker();
+  private filterStackFactory: FilterStackFactory;
+  constructor(private subchannel: Subchannel, private target: GrpcUri, options: ChannelOptions) {
+    this.channelzEnabled = options['grpc.enable_channelz'] !== 0;
+    this.channelzRef = registerChannelzChannel(uriToString(target),  () => ({
+      target: `${uriToString(target)} (${subchannel.getAddress()})`,
+      state: this.subchannel.getConnectivityState(),
+      trace: this.channelzTrace,
+      callTracker: this.callTracker,
+      children: this.childrenTracker.getChildLists()
+    }), this.channelzEnabled);
+    if (this.channelzEnabled) {
+      this.childrenTracker.refChild(subchannel.getChannelzRef());
+    }
+    this.filterStackFactory = new FilterStackFactory([new CompressionFilterFactory(this, options)]);
+  }
+
+  close(): void {
+    if (this.channelzEnabled) {
+      this.childrenTracker.unrefChild(this.subchannel.getChannelzRef());
+    }
+    unregisterChannelzRef(this.channelzRef);
+  }
+
+  getTarget(): string {
+    return uriToString(this.target);
+  }
+  getConnectivityState(tryToConnect: boolean): ConnectivityState {
+    throw new Error("Method not implemented.");
+  }
+  watchConnectivityState(currentState: ConnectivityState, deadline: Date | number, callback: (error?: Error) => void): void {
+    throw new Error("Method not implemented.");
+  }
+  getChannelzRef(): ChannelRef {
+    return this.channelzRef;
+  }
+  createCall(method: string, deadline: Deadline): Call {
+    const callOptions: CallStreamOptions = {
+      deadline: deadline,
+      host: getDefaultAuthority(this.target),
+      flags: Propagate.DEFAULTS,
+      parentCall: null
+    };
+    return new SubchannelCallWrapper(this.subchannel, method, this.filterStackFactory, callOptions, getNextCallNumber());
+  }
+}

package/node_modules/@grpc/grpc-js/src/status-builder.ts

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { StatusObject } from './call-interface';
+import { Status } from './constants';
+import { Metadata } from './metadata';
+
+/**
+ * A builder for gRPC status objects.
+ */
+export class StatusBuilder {
+  private code: Status | null;
+  private details: string | null;
+  private metadata: Metadata | null;
+
+  constructor() {
+    this.code = null;
+    this.details = null;
+    this.metadata = null;
+  }
+
+  /**
+   * Adds a status code to the builder.
+   */
+  withCode(code: Status): this {
+    this.code = code;
+    return this;
+  }
+
+  /**
+   * Adds details to the builder.
+   */
+  withDetails(details: string): this {
+    this.details = details;
+    return this;
+  }
+
+  /**
+   * Adds metadata to the builder.
+   */
+  withMetadata(metadata: Metadata): this {
+    this.metadata = metadata;
+    return this;
+  }
+
+  /**
+   * Builds the status object.
+   */
+  build(): Partial<StatusObject> {
+    const status: Partial<StatusObject> = {};
+
+    if (this.code !== null) {
+      status.code = this.code;
+    }
+
+    if (this.details !== null) {
+      status.details = this.details;
+    }
+
+    if (this.metadata !== null) {
+      status.metadata = this.metadata;
+    }
+
+    return status;
+  }
+}

package/node_modules/@grpc/grpc-js/src/stream-decoder.ts

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2019 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+enum ReadState {
+  NO_DATA,
+  READING_SIZE,
+  READING_MESSAGE,
+}
+
+export class StreamDecoder {
+  private readState: ReadState = ReadState.NO_DATA;
+  private readCompressFlag: Buffer = Buffer.alloc(1);
+  private readPartialSize: Buffer = Buffer.alloc(4);
+  private readSizeRemaining = 4;
+  private readMessageSize = 0;
+  private readPartialMessage: Buffer[] = [];
+  private readMessageRemaining = 0;
+
+  constructor(private maxReadMessageLength: number) {}
+
+  write(data: Buffer): Buffer[] {
+    let readHead = 0;
+    let toRead: number;
+    const result: Buffer[] = [];
+
+    while (readHead < data.length) {
+      switch (this.readState) {
+        case ReadState.NO_DATA:
+          this.readCompressFlag = data.slice(readHead, readHead + 1);
+          readHead += 1;
+          this.readState = ReadState.READING_SIZE;
+          this.readPartialSize.fill(0);
+          this.readSizeRemaining = 4;
+          this.readMessageSize = 0;
+          this.readMessageRemaining = 0;
+          this.readPartialMessage = [];
+          break;
+        case ReadState.READING_SIZE:
+          toRead = Math.min(data.length - readHead, this.readSizeRemaining);
+          data.copy(
+            this.readPartialSize,
+            4 - this.readSizeRemaining,
+            readHead,
+            readHead + toRead
+          );
+          this.readSizeRemaining -= toRead;
+          readHead += toRead;
+          // readSizeRemaining >=0 here
+          if (this.readSizeRemaining === 0) {
+            this.readMessageSize = this.readPartialSize.readUInt32BE(0);
+            if (this.maxReadMessageLength !== -1 && this.readMessageSize > this.maxReadMessageLength) {
+              throw new Error(`Received message larger than max (${this.readMessageSize} vs ${this.maxReadMessageLength})`);
+            }
+            this.readMessageRemaining = this.readMessageSize;
+            if (this.readMessageRemaining > 0) {
+              this.readState = ReadState.READING_MESSAGE;
+            } else {
+              const message = Buffer.concat(
+                [this.readCompressFlag, this.readPartialSize],
+                5
+              );
+
+              this.readState = ReadState.NO_DATA;
+              result.push(message);
+            }
+          }
+          break;
+        case ReadState.READING_MESSAGE:
+          toRead = Math.min(data.length - readHead, this.readMessageRemaining);
+          this.readPartialMessage.push(data.slice(readHead, readHead + toRead));
+          this.readMessageRemaining -= toRead;
+          readHead += toRead;
+          // readMessageRemaining >=0 here
+          if (this.readMessageRemaining === 0) {
+            // At this point, we have read a full message
+            const framedMessageBuffers = [
+              this.readCompressFlag,
+              this.readPartialSize,
+            ].concat(this.readPartialMessage);
+            const framedMessage = Buffer.concat(
+              framedMessageBuffers,
+              this.readMessageSize + 5
+            );
+
+            this.readState = ReadState.NO_DATA;
+            result.push(framedMessage);
+          }
+          break;
+        default:
+          throw new Error('Unexpected read state');
+      }
+    }
+
+    return result;
+  }
+}

package/node_modules/@grpc/grpc-js/src/subchannel-address.ts

@@ -0,0 +1,252 @@
+/*
+ * Copyright 2021 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { isIP, isIPv6 } from 'net';
+
+export interface TcpSubchannelAddress {
+  port: number;
+  host: string;
+}
+
+export interface IpcSubchannelAddress {
+  path: string;
+}
+/**
+ * This represents a single backend address to connect to. This interface is a
+ * subset of net.SocketConnectOpts, i.e. the options described at
+ * https://nodejs.org/api/net.html#net_socket_connect_options_connectlistener.
+ * Those are in turn a subset of the options that can be passed to http2.connect.
+ */
+
+export type SubchannelAddress = TcpSubchannelAddress | IpcSubchannelAddress;
+
+export function isTcpSubchannelAddress(
+  address: SubchannelAddress
+): address is TcpSubchannelAddress {
+  return 'port' in address;
+}
+
+export function subchannelAddressEqual(
+  address1?: SubchannelAddress,
+  address2?: SubchannelAddress
+): boolean {
+  if (!address1 && !address2) {
+    return true;
+  }
+  if (!address1 || !address2) {
+    return false;
+  }
+  if (isTcpSubchannelAddress(address1)) {
+    return (
+      isTcpSubchannelAddress(address2) &&
+      address1.host === address2.host &&
+      address1.port === address2.port
+    );
+  } else {
+    return !isTcpSubchannelAddress(address2) && address1.path === address2.path;
+  }
+}
+
+export function subchannelAddressToString(address: SubchannelAddress): string {
+  if (isTcpSubchannelAddress(address)) {
+    if (isIPv6(address.host)) {
+      return '[' + address.host + ']:' + address.port;
+    } else {
+      return address.host + ':' + address.port;
+    }
+  } else {
+    return address.path;
+  }
+}
+
+const DEFAULT_PORT = 443;
+
+export function stringToSubchannelAddress(
+  addressString: string,
+  port?: number
+): SubchannelAddress {
+  if (isIP(addressString)) {
+    return {
+      host: addressString,
+      port: port ?? DEFAULT_PORT,
+    };
+  } else {
+    return {
+      path: addressString,
+    };
+  }
+}
+
+export interface Endpoint {
+  addresses: SubchannelAddress[];
+}
+
+export function endpointEqual(endpoint1: Endpoint, endpoint2: Endpoint) {
+  if (endpoint1.addresses.length !== endpoint2.addresses.length) {
+    return false;
+  }
+  for (let i = 0; i < endpoint1.addresses.length; i++) {
+    if (
+      !subchannelAddressEqual(endpoint1.addresses[i], endpoint2.addresses[i])
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function endpointToString(endpoint: Endpoint): string {
+  return (
+    '[' + endpoint.addresses.map(subchannelAddressToString).join(', ') + ']'
+  );
+}
+
+export function endpointHasAddress(
+  endpoint: Endpoint,
+  expectedAddress: SubchannelAddress
+): boolean {
+  for (const address of endpoint.addresses) {
+    if (subchannelAddressEqual(address, expectedAddress)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+interface EndpointMapEntry<ValueType> {
+  key: Endpoint;
+  value: ValueType;
+}
+
+function endpointEqualUnordered(
+  endpoint1: Endpoint,
+  endpoint2: Endpoint
+): boolean {
+  if (endpoint1.addresses.length !== endpoint2.addresses.length) {
+    return false;
+  }
+  for (const address1 of endpoint1.addresses) {
+    let matchFound = false;
+    for (const address2 of endpoint2.addresses) {
+      if (subchannelAddressEqual(address1, address2)) {
+        matchFound = true;
+        break;
+      }
+    }
+    if (!matchFound) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export class EndpointMap<ValueType> {
+  private map: Set<EndpointMapEntry<ValueType>> = new Set();
+
+  get size() {
+    return this.map.size;
+  }
+
+  getForSubchannelAddress(address: SubchannelAddress): ValueType | undefined {
+    for (const entry of this.map) {
+      if (endpointHasAddress(entry.key, address)) {
+        return entry.value;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Delete any entries in this map with keys that are not in endpoints
+   * @param endpoints
+   */
+  deleteMissing(endpoints: Endpoint[]): ValueType[] {
+    const removedValues: ValueType[] = [];
+    for (const entry of this.map) {
+      let foundEntry = false;
+      for (const endpoint of endpoints) {
+        if (endpointEqualUnordered(endpoint, entry.key)) {
+          foundEntry = true;
+        }
+      }
+      if (!foundEntry) {
+        removedValues.push(entry.value);
+        this.map.delete(entry);
+      }
+    }
+    return removedValues;
+  }
+
+  get(endpoint: Endpoint): ValueType | undefined {
+    for (const entry of this.map) {
+      if (endpointEqualUnordered(endpoint, entry.key)) {
+        return entry.value;
+      }
+    }
+    return undefined;
+  }
+
+  set(endpoint: Endpoint, mapEntry: ValueType) {
+    for (const entry of this.map) {
+      if (endpointEqualUnordered(endpoint, entry.key)) {
+        entry.value = mapEntry;
+        return;
+      }
+    }
+    this.map.add({ key: endpoint, value: mapEntry });
+  }
+
+  delete(endpoint: Endpoint) {
+    for (const entry of this.map) {
+      if (endpointEqualUnordered(endpoint, entry.key)) {
+        this.map.delete(entry);
+        return;
+      }
+    }
+  }
+
+  has(endpoint: Endpoint): boolean {
+    for (const entry of this.map) {
+      if (endpointEqualUnordered(endpoint, entry.key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  clear() {
+    this.map.clear();
+  }
+
+  *keys(): IterableIterator<Endpoint> {
+    for (const entry of this.map) {
+      yield entry.key;
+    }
+  }
+
+  *values(): IterableIterator<ValueType> {
+    for (const entry of this.map) {
+      yield entry.value;
+    }
+  }
+
+  *entries(): IterableIterator<[Endpoint, ValueType]> {
+    for (const entry of this.map) {
+      yield [entry.key, entry.value];
+    }
+  }
+}