claude-autopm 3.1.1 → 3.2.0

package/packages/plugin-devops/node_modules/jest-worker/build/base/BaseWorkerPool.js

@@ -1,156 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-exports.default = void 0;
-function _mergeStream() {
-  const data = _interopRequireDefault(require('merge-stream'));
-  _mergeStream = function () {
-    return data;
-  };
-  return data;
-}
-var _types = require('../types');
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {default: obj};
-}
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-// How long to wait for the child process to terminate
-// after CHILD_MESSAGE_END before sending force exiting.
-const FORCE_EXIT_DELAY = 500;
-
-/* istanbul ignore next */
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const emptyMethod = () => {};
-class BaseWorkerPool {
-  _stderr;
-  _stdout;
-  _options;
-  _workers;
-  _workerPath;
-  constructor(workerPath, options) {
-    this._options = options;
-    this._workerPath = workerPath;
-    this._workers = new Array(options.numWorkers);
-    const stdout = (0, _mergeStream().default)();
-    const stderr = (0, _mergeStream().default)();
-    const {forkOptions, maxRetries, resourceLimits, setupArgs} = options;
-    for (let i = 0; i < options.numWorkers; i++) {
-      const workerOptions = {
-        forkOptions,
-        idleMemoryLimit: this._options.idleMemoryLimit,
-        maxRetries,
-        resourceLimits,
-        setupArgs,
-        workerId: i,
-        workerPath
-      };
-      const worker = this.createWorker(workerOptions);
-      const workerStdout = worker.getStdout();
-      const workerStderr = worker.getStderr();
-      if (workerStdout) {
-        stdout.add(workerStdout);
-      }
-      if (workerStderr) {
-        stderr.add(workerStderr);
-      }
-      this._workers[i] = worker;
-    }
-    this._stdout = stdout;
-    this._stderr = stderr;
-  }
-  getStderr() {
-    return this._stderr;
-  }
-  getStdout() {
-    return this._stdout;
-  }
-  getWorkers() {
-    return this._workers;
-  }
-  getWorkerById(workerId) {
-    return this._workers[workerId];
-  }
-  restartWorkerIfShutDown(workerId) {
-    if (this._workers[workerId].state === _types.WorkerStates.SHUT_DOWN) {
-      const {forkOptions, maxRetries, resourceLimits, setupArgs} =
-        this._options;
-      const workerOptions = {
-        forkOptions,
-        idleMemoryLimit: this._options.idleMemoryLimit,
-        maxRetries,
-        resourceLimits,
-        setupArgs,
-        workerId,
-        workerPath: this._workerPath
-      };
-      const worker = this.createWorker(workerOptions);
-      this._workers[workerId] = worker;
-    }
-  }
-  createWorker(_workerOptions) {
-    throw Error('Missing method createWorker in WorkerPool');
-  }
-  async start() {
-    await Promise.all(
-      this._workers.map(async worker => {
-        await worker.waitForWorkerReady();
-        await new Promise((resolve, reject) => {
-          worker.send(
-            [_types.CHILD_MESSAGE_CALL_SETUP],
-            emptyMethod,
-            error => {
-              if (error) {
-                reject(error);
-              } else {
-                resolve();
-              }
-            },
-            emptyMethod
-          );
-        });
-      })
-    );
-  }
-  async end() {
-    // We do not cache the request object here. If so, it would only be only
-    // processed by one of the workers, and we want them all to close.
-    const workerExitPromises = this._workers.map(async worker => {
-      worker.send(
-        [_types.CHILD_MESSAGE_END, false],
-        emptyMethod,
-        emptyMethod,
-        emptyMethod
-      );
-
-      // Schedule a force exit in case worker fails to exit gracefully so
-      // await worker.waitForExit() never takes longer than FORCE_EXIT_DELAY
-      let forceExited = false;
-      const forceExitTimeout = setTimeout(() => {
-        worker.forceExit();
-        forceExited = true;
-      }, FORCE_EXIT_DELAY);
-      await worker.waitForExit();
-      // Worker ideally exited gracefully, don't send force exit then
-      clearTimeout(forceExitTimeout);
-      return forceExited;
-    });
-    const workerExits = await Promise.all(workerExitPromises);
-    return workerExits.reduce(
-      (result, forceExited) => ({
-        forceExited: result.forceExited || forceExited
-      }),
-      {
-        forceExited: false
-      }
-    );
-  }
-}
-exports.default = BaseWorkerPool;

package/packages/plugin-devops/node_modules/jest-worker/build/index.d.ts

@@ -1,355 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-/// <reference types="node" />
-
-import type {ForkOptions} from 'child_process';
-import type {ResourceLimits} from 'worker_threads';
-
-declare const CHILD_MESSAGE_CALL = 1;
-
-declare const CHILD_MESSAGE_CALL_SETUP = 4;
-
-declare const CHILD_MESSAGE_END = 2;
-
-declare const CHILD_MESSAGE_INITIALIZE = 0;
-
-declare const CHILD_MESSAGE_MEM_USAGE = 3;
-
-declare type ChildMessage =
-  | ChildMessageInitialize
-  | ChildMessageCall
-  | ChildMessageEnd
-  | ChildMessageMemUsage
-  | ChildMessageCallSetup;
-
-declare type ChildMessageCall = [
-  type: typeof CHILD_MESSAGE_CALL,
-  isProcessed: boolean,
-  methodName: string,
-  args: Array<unknown>,
-];
-
-declare type ChildMessageCallSetup = [type: typeof CHILD_MESSAGE_CALL_SETUP];
-
-declare type ChildMessageEnd = [
-  type: typeof CHILD_MESSAGE_END,
-  isProcessed: boolean,
-];
-
-declare type ChildMessageInitialize = [
-  type: typeof CHILD_MESSAGE_INITIALIZE,
-  isProcessed: boolean,
-  fileName: string,
-  setupArgs: Array<unknown>,
-  workerId: string | undefined,
-];
-
-declare type ChildMessageMemUsage = [type: typeof CHILD_MESSAGE_MEM_USAGE];
-
-declare type ComputeTaskPriorityCallback = (
-  method: string,
-  ...args: Array<unknown>
-) => number;
-
-declare type ExcludeReservedKeys<K> = Exclude<K, ReservedKeys>;
-
-/**
- * First-in, First-out task queue that manages a dedicated pool
- * for each worker as well as a shared queue. The FIFO ordering is guaranteed
- * across the worker specific and shared queue.
- */
-export declare class FifoQueue implements TaskQueue {
-  private _workerQueues;
-  private readonly _sharedQueue;
-  enqueue(task: QueueChildMessage, workerId?: number): void;
-  dequeue(workerId: number): QueueChildMessage | null;
-}
-
-declare type FunctionLike = (...args: any) => unknown;
-
-declare type HeapItem = {
-  priority: number;
-};
-
-export declare type JestWorkerFarm<T extends Record<string, unknown>> =
-  Worker_2 & WorkerModule<T>;
-
-export declare function messageParent(
-  message: unknown,
-  parentProcess?: NodeJS.Process,
-): void;
-
-declare type MethodLikeKeys<T> = {
-  [K in keyof T]: T[K] extends FunctionLike ? K : never;
-}[keyof T];
-
-declare class MinHeap<TItem extends HeapItem> {
-  private readonly _heap;
-  peek(): TItem | null;
-  add(item: TItem): void;
-  poll(): TItem | null;
-}
-
-declare type OnCustomMessage = (message: Array<unknown> | unknown) => void;
-
-declare type OnEnd = (err: Error | null, result: unknown) => void;
-
-declare type OnStart = (worker: WorkerInterface) => void;
-
-declare type OnStateChangeHandler = (
-  state: WorkerStates,
-  oldState: WorkerStates,
-) => void;
-
-declare type PoolExitResult = {
-  forceExited: boolean;
-};
-
-/**
- * Priority queue that processes tasks in natural ordering (lower priority first)
- * according to the priority computed by the function passed in the constructor.
- *
- * FIFO ordering isn't guaranteed for tasks with the same priority.
- *
- * Worker specific tasks with the same priority as a non-worker specific task
- * are always processed first.
- */
-export declare class PriorityQueue implements TaskQueue {
-  private readonly _computePriority;
-  private _queue;
-  private readonly _sharedQueue;
-  constructor(_computePriority: ComputeTaskPriorityCallback);
-  enqueue(task: QueueChildMessage, workerId?: number): void;
-  _enqueue(task: QueueChildMessage, queue: MinHeap<QueueItem>): void;
-  dequeue(workerId: number): QueueChildMessage | null;
-  _getWorkerQueue(workerId: number): MinHeap<QueueItem>;
-}
-
-export declare interface PromiseWithCustomMessage<T> extends Promise<T> {
-  UNSTABLE_onCustomMessage?: (listener: OnCustomMessage) => () => void;
-}
-
-declare type Promisify<T extends FunctionLike> = ReturnType<T> extends Promise<
-  infer R
->
-  ? (...args: Parameters<T>) => Promise<R>
-  : (...args: Parameters<T>) => Promise<ReturnType<T>>;
-
-declare type QueueChildMessage = {
-  request: ChildMessageCall;
-  onStart: OnStart;
-  onEnd: OnEnd;
-  onCustomMessage: OnCustomMessage;
-};
-
-declare type QueueItem = {
-  task: QueueChildMessage;
-  priority: number;
-};
-
-declare type ReservedKeys =
-  | 'end'
-  | 'getStderr'
-  | 'getStdout'
-  | 'setup'
-  | 'teardown';
-
-export declare interface TaskQueue {
-  /**
-   * Enqueues the task in the queue for the specified worker or adds it to the
-   * queue shared by all workers
-   * @param task the task to queue
-   * @param workerId the id of the worker that should process this task or undefined
-   * if there's no preference.
-   */
-  enqueue(task: QueueChildMessage, workerId?: number): void;
-  /**
-   * Dequeues the next item from the queue for the specified worker
-   * @param workerId the id of the worker for which the next task should be retrieved
-   */
-  dequeue(workerId: number): QueueChildMessage | null;
-}
-
-/**
- * The Jest farm (publicly called "Worker") is a class that allows you to queue
- * methods across multiple child processes, in order to parallelize work. This
- * is done by providing an absolute path to a module that will be loaded on each
- * of the child processes, and bridged to the main process.
- *
- * Bridged methods are specified by using the "exposedMethods" property of the
- * "options" object. This is an array of strings, where each of them corresponds
- * to the exported name in the loaded module.
- *
- * You can also control the amount of workers by using the "numWorkers" property
- * of the "options" object, and the settings passed to fork the process through
- * the "forkOptions" property. The amount of workers defaults to the amount of
- * CPUS minus one.
- *
- * Queueing calls can be done in two ways:
- *   - Standard method: calls will be redirected to the first available worker,
- *     so they will get executed as soon as they can.
- *
- *   - Sticky method: if a "computeWorkerKey" method is provided within the
- *     config, the resulting string of this method will be used as a key.
- *     Every time this key is returned, it is guaranteed that your job will be
- *     processed by the same worker. This is specially useful if your workers
- *     are caching results.
- */
-declare class Worker_2 {
-  private _ending;
-  private readonly _farm;
-  private readonly _options;
-  private readonly _workerPool;
-  constructor(workerPath: string | URL, options?: WorkerFarmOptions);
-  private _bindExposedWorkerMethods;
-  private _callFunctionWithArgs;
-  getStderr(): NodeJS.ReadableStream;
-  getStdout(): NodeJS.ReadableStream;
-  start(): Promise<void>;
-  end(): Promise<PoolExitResult>;
-}
-export {Worker_2 as Worker};
-
-declare type WorkerCallback = (
-  workerId: number,
-  request: ChildMessage,
-  onStart: OnStart,
-  onEnd: OnEnd,
-  onCustomMessage: OnCustomMessage,
-) => void;
-
-declare enum WorkerEvents {
-  STATE_CHANGE = 'state-change',
-}
-
-export declare type WorkerFarmOptions = {
-  computeWorkerKey?: (method: string, ...args: Array<unknown>) => string | null;
-  enableWorkerThreads?: boolean;
-  exposedMethods?: ReadonlyArray<string>;
-  forkOptions?: ForkOptions;
-  maxRetries?: number;
-  numWorkers?: number;
-  resourceLimits?: ResourceLimits;
-  setupArgs?: Array<unknown>;
-  taskQueue?: TaskQueue;
-  WorkerPool?: new (
-    workerPath: string,
-    options?: WorkerPoolOptions,
-  ) => WorkerPoolInterface;
-  workerSchedulingPolicy?: WorkerSchedulingPolicy;
-  idleMemoryLimit?: number;
-};
-
-declare interface WorkerInterface {
-  get state(): WorkerStates;
-  send(
-    request: ChildMessage,
-    onProcessStart: OnStart,
-    onProcessEnd: OnEnd,
-    onCustomMessage: OnCustomMessage,
-  ): void;
-  waitForExit(): Promise<void>;
-  forceExit(): void;
-  getWorkerId(): number;
-  getStderr(): NodeJS.ReadableStream | null;
-  getStdout(): NodeJS.ReadableStream | null;
-  /**
-   * Some system level identifier for the worker. IE, process id, thread id, etc.
-   */
-  getWorkerSystemId(): number;
-  getMemoryUsage(): Promise<number | null>;
-  /**
-   * Checks to see if the child worker is actually running.
-   */
-  isWorkerRunning(): boolean;
-  /**
-   * When the worker child is started and ready to start handling requests.
-   *
-   * @remarks
-   * This mostly exists to help with testing so that you don't check the status
-   * of things like isWorkerRunning before it actually is.
-   */
-  waitForWorkerReady(): Promise<void>;
-}
-
-declare type WorkerModule<T> = {
-  [K in keyof T as Extract<
-    ExcludeReservedKeys<K>,
-    MethodLikeKeys<T>
-  >]: T[K] extends FunctionLike ? Promisify<T[K]> : never;
-};
-
-declare type WorkerOptions_2 = {
-  forkOptions: ForkOptions;
-  resourceLimits: ResourceLimits;
-  setupArgs: Array<unknown>;
-  maxRetries: number;
-  workerId: number;
-  workerData?: unknown;
-  workerPath: string;
-  /**
-   * After a job has executed the memory usage it should return to.
-   *
-   * @remarks
-   * Note this is different from ResourceLimits in that it checks at idle, after
-   * a job is complete. So you could have a resource limit of 500MB but an idle
-   * limit of 50MB. The latter will only trigger if after a job has completed the
-   * memory usage hasn't returned back down under 50MB.
-   */
-  idleMemoryLimit?: number;
-  /**
-   * This mainly exists so the path can be changed during testing.
-   * https://github.com/jestjs/jest/issues/9543
-   */
-  childWorkerPath?: string;
-  /**
-   * This is useful for debugging individual tests allowing you to see
-   * the raw output of the worker.
-   */
-  silent?: boolean;
-  /**
-   * Used to immediately bind event handlers.
-   */
-  on?: {
-    [WorkerEvents.STATE_CHANGE]:
-      | OnStateChangeHandler
-      | ReadonlyArray<OnStateChangeHandler>;
-  };
-};
-
-export declare interface WorkerPoolInterface {
-  getStderr(): NodeJS.ReadableStream;
-  getStdout(): NodeJS.ReadableStream;
-  getWorkers(): Array<WorkerInterface>;
-  createWorker(options: WorkerOptions_2): WorkerInterface;
-  send: WorkerCallback;
-  start(): Promise<void>;
-  end(): Promise<PoolExitResult>;
-}
-
-export declare type WorkerPoolOptions = {
-  setupArgs: Array<unknown>;
-  forkOptions: ForkOptions;
-  resourceLimits: ResourceLimits;
-  maxRetries: number;
-  numWorkers: number;
-  enableWorkerThreads: boolean;
-  idleMemoryLimit?: number;
-};
-
-declare type WorkerSchedulingPolicy = 'round-robin' | 'in-order';
-
-declare enum WorkerStates {
-  STARTING = 'starting',
-  OK = 'ok',
-  OUT_OF_MEMORY = 'oom',
-  RESTARTING = 'restarting',
-  SHUTTING_DOWN = 'shutting-down',
-  SHUT_DOWN = 'shut-down',
-}
-
-export {};

package/packages/plugin-devops/node_modules/jest-worker/build/index.js

@@ -1,192 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-Object.defineProperty(exports, 'FifoQueue', {
-  enumerable: true,
-  get: function () {
-    return _FifoQueue.default;
-  }
-});
-Object.defineProperty(exports, 'PriorityQueue', {
-  enumerable: true,
-  get: function () {
-    return _PriorityQueue.default;
-  }
-});
-exports.Worker = void 0;
-Object.defineProperty(exports, 'messageParent', {
-  enumerable: true,
-  get: function () {
-    return _messageParent.default;
-  }
-});
-function _os() {
-  const data = require('os');
-  _os = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = require('path');
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _url() {
-  const data = require('url');
-  _url = function () {
-    return data;
-  };
-  return data;
-}
-var _Farm = _interopRequireDefault(require('./Farm'));
-var _WorkerPool = _interopRequireDefault(require('./WorkerPool'));
-var _PriorityQueue = _interopRequireDefault(require('./PriorityQueue'));
-var _FifoQueue = _interopRequireDefault(require('./FifoQueue'));
-var _messageParent = _interopRequireDefault(require('./workers/messageParent'));
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {default: obj};
-}
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-function getExposedMethods(workerPath, options) {
-  let exposedMethods = options.exposedMethods;
-
-  // If no methods list is given, try getting it by auto-requiring the module.
-  if (!exposedMethods) {
-    const module = require(workerPath);
-    exposedMethods = Object.keys(module).filter(
-      name => typeof module[name] === 'function'
-    );
-    if (typeof module === 'function') {
-      exposedMethods = [...exposedMethods, 'default'];
-    }
-  }
-  return exposedMethods;
-}
-function getNumberOfCpus() {
-  return typeof _os().availableParallelism === 'function'
-    ? (0, _os().availableParallelism)()
-    : (0, _os().cpus)().length;
-}
-
-/**
- * The Jest farm (publicly called "Worker") is a class that allows you to queue
- * methods across multiple child processes, in order to parallelize work. This
- * is done by providing an absolute path to a module that will be loaded on each
- * of the child processes, and bridged to the main process.
- *
- * Bridged methods are specified by using the "exposedMethods" property of the
- * "options" object. This is an array of strings, where each of them corresponds
- * to the exported name in the loaded module.
- *
- * You can also control the amount of workers by using the "numWorkers" property
- * of the "options" object, and the settings passed to fork the process through
- * the "forkOptions" property. The amount of workers defaults to the amount of
- * CPUS minus one.
- *
- * Queueing calls can be done in two ways:
- *   - Standard method: calls will be redirected to the first available worker,
- *     so they will get executed as soon as they can.
- *
- *   - Sticky method: if a "computeWorkerKey" method is provided within the
- *     config, the resulting string of this method will be used as a key.
- *     Every time this key is returned, it is guaranteed that your job will be
- *     processed by the same worker. This is specially useful if your workers
- *     are caching results.
- */
-class Worker {
-  _ending;
-  _farm;
-  _options;
-  _workerPool;
-  constructor(workerPath, options) {
-    this._options = {
-      ...options
-    };
-    this._ending = false;
-    if (typeof workerPath !== 'string') {
-      workerPath = workerPath.href;
-    }
-    if (workerPath.startsWith('file:')) {
-      workerPath = (0, _url().fileURLToPath)(workerPath);
-    } else if (!(0, _path().isAbsolute)(workerPath)) {
-      throw new Error(`'workerPath' must be absolute, got '${workerPath}'`);
-    }
-    const workerPoolOptions = {
-      enableWorkerThreads: this._options.enableWorkerThreads ?? false,
-      forkOptions: this._options.forkOptions ?? {},
-      idleMemoryLimit: this._options.idleMemoryLimit,
-      maxRetries: this._options.maxRetries ?? 3,
-      numWorkers:
-        this._options.numWorkers ?? Math.max(getNumberOfCpus() - 1, 1),
-      resourceLimits: this._options.resourceLimits ?? {},
-      setupArgs: this._options.setupArgs ?? []
-    };
-    if (this._options.WorkerPool) {
-      this._workerPool = new this._options.WorkerPool(
-        workerPath,
-        workerPoolOptions
-      );
-    } else {
-      this._workerPool = new _WorkerPool.default(workerPath, workerPoolOptions);
-    }
-    this._farm = new _Farm.default(
-      workerPoolOptions.numWorkers,
-      this._workerPool.send.bind(this._workerPool),
-      {
-        computeWorkerKey: this._options.computeWorkerKey,
-        taskQueue: this._options.taskQueue,
-        workerSchedulingPolicy: this._options.workerSchedulingPolicy
-      }
-    );
-    this._bindExposedWorkerMethods(workerPath, this._options);
-  }
-  _bindExposedWorkerMethods(workerPath, options) {
-    getExposedMethods(workerPath, options).forEach(name => {
-      if (name.startsWith('_')) {
-        return;
-      }
-
-      // eslint-disable-next-line no-prototype-builtins
-      if (this.constructor.prototype.hasOwnProperty(name)) {
-        throw new TypeError(`Cannot define a method called ${name}`);
-      }
-
-      // @ts-expect-error: dynamic extension of the class instance is expected.
-      this[name] = this._callFunctionWithArgs.bind(this, name);
-    });
-  }
-  _callFunctionWithArgs(method, ...args) {
-    if (this._ending) {
-      throw new Error('Farm is ended, no more calls can be done to it');
-    }
-    return this._farm.doWork(method, ...args);
-  }
-  getStderr() {
-    return this._workerPool.getStderr();
-  }
-  getStdout() {
-    return this._workerPool.getStdout();
-  }
-  async start() {
-    await this._workerPool.start();
-  }
-  async end() {
-    if (this._ending) {
-      throw new Error('Farm is ended, no more calls can be done to it');
-    }
-    this._ending = true;
-    return this._workerPool.end();
-  }
-}
-exports.Worker = Worker;