agent-skill-manager 1.22.0 → 2.0.0

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

@@ -1,248 +0,0 @@
-/*
- * 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

@@ -1,80 +0,0 @@
-/*
- * 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

@@ -1,110 +0,0 @@
-/*
- * 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

@@ -1,252 +0,0 @@
-/*
- * 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];
-    }
-  }
-}