global-agent 4.1.2 → 4.1.3

package/dist/routines/index.d.ts

@@ -0,0 +1 @@
+export { default as bootstrap, } from './bootstrap';

package/dist/routines/index.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrap = void 0;
+var bootstrap_1 = require("./bootstrap");
+Object.defineProperty(exports, "bootstrap", { enumerable: true, get: function () { return __importDefault(bootstrap_1).default; } });

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Agent as HttpAgent } from 'http';
+import type { Agent as HttpsAgent } from 'https';
+import type { Socket } from 'net';
+import type { TLSSocket } from 'tls';
+import type { Logger } from './Logger';
+export type ProxyConfigurationType = {
+    authorization: string | null;
+    hostname: string;
+    port: number;
+};
+export type TlsConfigurationType = {
+    ca?: string[] | string;
+    cert?: string;
+    ciphers?: string;
+    clientCertEngine?: string;
+    crl?: string;
+    dhparam?: string;
+    ecdhCurve?: string;
+    honorCipherOrder?: boolean;
+    key?: string;
+    passphrase?: string;
+    pfx?: string;
+    rejectUnauthorized?: boolean;
+    secureOptions?: number;
+    secureProtocol?: string;
+    servername?: string;
+    sessionIdContext?: string;
+};
+export type ConnectionConfigurationType = {
+    host: string;
+    port: number;
+    tls?: TlsConfigurationType;
+    proxy: ProxyConfigurationType;
+};
+export type ConnectionCallbackType = (error: Error | null, socket?: Socket | TLSSocket) => void;
+export type AgentType = HttpAgent | HttpsAgent;
+export type IsProxyConfiguredMethodType = () => boolean;
+export type MustUrlUseProxyMethodType = (url: string) => boolean;
+export type GetUrlProxyMethodType = (url: string) => ProxyConfigurationType;
+export type ProtocolType = 'http:' | 'https:';
+export type ProxyAgentConfigurationInputType = {
+    environmentVariableNamespace?: string;
+    forceGlobalAgent?: boolean;
+    socketConnectionTimeout?: number;
+    ca?: string[] | string;
+    logger?: Logger;
+};
+export type ProxyAgentConfigurationType = {
+    environmentVariableNamespace: string;
+    forceGlobalAgent: boolean;
+    socketConnectionTimeout: number;
+    ca?: string[] | string;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utilities/bindHttpMethod.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+type AgentType = http.Agent | https.Agent;
+declare const _default: (originalMethod: Function, agent: AgentType, forceGlobalAgent: boolean) => (...args: any[]) => any;
+export default _default;

package/dist/utilities/bindHttpMethod.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+exports.default = (originalMethod, agent, forceGlobalAgent) => {
+    return (...args) => {
+        let url;
+        let options;
+        let callback;
+        if (typeof args[0] === 'string' || args[0] instanceof URL) {
+            url = args[0];
+            if (typeof args[1] === 'function') {
+                options = {};
+                callback = args[1];
+            }
+            else {
+                options = {
+                    ...args[1],
+                };
+                callback = args[2];
+            }
+        }
+        else {
+            options = {
+                ...args[0],
+            };
+            callback = args[1];
+        }
+        if (forceGlobalAgent) {
+            options.agent = agent;
+        }
+        else {
+            if (!options.agent) {
+                options.agent = agent;
+            }
+            if (options.agent === http_1.default.globalAgent || options.agent === https_1.default.globalAgent) {
+                options.agent = agent;
+            }
+        }
+        if (url) {
+            return originalMethod(url, options, callback);
+        }
+        else {
+            return originalMethod(options, callback);
+        }
+    };
+};

package/dist/utilities/index.d.ts

@@ -0,0 +1,3 @@
+export { default as bindHttpMethod, } from './bindHttpMethod';
+export { default as isUrlMatchingNoProxy, } from './isUrlMatchingNoProxy';
+export { default as parseProxyUrl, } from './parseProxyUrl';

package/dist/utilities/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProxyUrl = exports.isUrlMatchingNoProxy = exports.bindHttpMethod = void 0;
+var bindHttpMethod_1 = require("./bindHttpMethod");
+Object.defineProperty(exports, "bindHttpMethod", { enumerable: true, get: function () { return __importDefault(bindHttpMethod_1).default; } });
+var isUrlMatchingNoProxy_1 = require("./isUrlMatchingNoProxy");
+Object.defineProperty(exports, "isUrlMatchingNoProxy", { enumerable: true, get: function () { return __importDefault(isUrlMatchingNoProxy_1).default; } });
+var parseProxyUrl_1 = require("./parseProxyUrl");
+Object.defineProperty(exports, "parseProxyUrl", { enumerable: true, get: function () { return __importDefault(parseProxyUrl_1).default; } });

package/dist/utilities/isUrlMatchingNoProxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (subjectUrl: string, noProxy: string) => boolean;
+export default _default;

package/dist/utilities/isUrlMatchingNoProxy.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const matcher_1 = __importDefault(require("matcher"));
+const errors_1 = require("../errors");
+exports.default = (subjectUrl, noProxy) => {
+    const subjectUrlTokens = new URL(subjectUrl);
+    const rules = noProxy.split(/[\s,]+/).filter(Boolean);
+    for (const rule of rules) {
+        const ruleMatch = rule
+            .replace(/^(?<leadingDot>\.)/, '*')
+            .match(/^(?<hostname>.+?)(?::(?<port>\d+))?$/);
+        if (!ruleMatch || !ruleMatch.groups) {
+            throw new errors_1.UnexpectedStateError('Invalid NO_PROXY pattern.');
+        }
+        if (!ruleMatch.groups.hostname) {
+            throw new errors_1.UnexpectedStateError('NO_PROXY entry pattern must include hostname. Use * to match any hostname.');
+        }
+        const hostnameIsMatch = matcher_1.default.isMatch(subjectUrlTokens.hostname, ruleMatch.groups.hostname);
+        if (hostnameIsMatch && (!ruleMatch.groups || !ruleMatch.groups.port || subjectUrlTokens.port && subjectUrlTokens.port === ruleMatch.groups.port)) {
+            return true;
+        }
+    }
+    return false;
+};

package/dist/utilities/isUrlMatchingNoProxy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/isUrlMatchingNoProxy.test.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const isUrlMatchingNoProxy_1 = __importDefault(require("./isUrlMatchingNoProxy"));
+(0, vitest_1.test)('returns `true` if hosts match', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', 'foo.com')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts match (IP)', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://127.0.0.1/', '127.0.0.1')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts match (using asterisk wildcard)', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://bar.foo.com/', '*.foo.com')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if domain matches (using dot wildcard)', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', '.foo.com')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if subdomain matches (using dot wildcard)', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://bar.foo.com/', '.foo.com')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts match (*) and ports match', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com:8080/', '*:8080')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts and ports match', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com:8080/', 'foo.com:8080')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts match and NO_PROXY does not define port', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com:8080/', 'foo.com')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts (IP) and ports match', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://127.0.0.1:8080/', '127.0.0.1:8080')).toBe(true);
+});
+(0, vitest_1.test)('returns `false` if hosts match and ports do not match (diffferent port)', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com:8080/', 'foo.com:8000')).toBe(false);
+});
+(0, vitest_1.test)('returns `false` if hosts match and ports do not match (port not present subject)', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', 'foo.com:8000')).toBe(false);
+});
+(0, vitest_1.test)('returns `true` if hosts match and ports do not match (port not present NO_PROXY)', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com:8000/', 'foo.com')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts match in one of multiple rules separated with a comma', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', 'bar.org,foo.com,baz.io')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts match in one of multiple rules separated with a comma and a space', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', 'bar.org, foo.com, baz.io')).toBe(true);
+});
+(0, vitest_1.test)('returns `true` if hosts match in one of multiple rules separated with a space', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', 'bar.org foo.com baz.io')).toBe(true);
+});
+(0, vitest_1.test)('handles trailing newline in NO_PROXY', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', 'foo.com\n')).toBe(true);
+});
+(0, vitest_1.test)('handles trailing whitespace in NO_PROXY', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', 'foo.com   ')).toBe(true);
+});
+(0, vitest_1.test)('handles leading whitespace in NO_PROXY', () => {
+    (0, vitest_1.expect)((0, isUrlMatchingNoProxy_1.default)('http://foo.com/', '  foo.com')).toBe(true);
+});

package/dist/utilities/parseBoolean.d.ts

@@ -0,0 +1 @@
+export declare const parseBoolean: (value: any) => boolean;

package/dist/utilities/parseBoolean.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = void 0;
+const parseBoolean = function (value) {
+    switch (Object.prototype.toString.call(value)) {
+        case '[object String]':
+            return ['true', 't', 'yes', 'y', 'on', '1'].includes(value.trim().toLowerCase());
+        case '[object Number]':
+            return value.valueOf() === 1;
+        case '[object Boolean]':
+            return value.valueOf();
+        default:
+            return false;
+    }
+};
+exports.parseBoolean = parseBoolean;

package/dist/utilities/parseProxyUrl.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (url: string) => {
+    authorization: string | null;
+    hostname: string;
+    port: number;
+};
+export default _default;

package/dist/utilities/parseProxyUrl.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+exports.default = (url) => {
+    const urlTokens = new URL(url);
+    if (urlTokens.search !== '') {
+        throw new errors_1.UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have query.');
+    }
+    if (urlTokens.hash !== '') {
+        throw new errors_1.UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have hash.');
+    }
+    if (urlTokens.protocol !== 'http:') {
+        throw new errors_1.UnexpectedStateError('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL protocol must be "http:".');
+    }
+    let port = 80;
+    if (urlTokens.port) {
+        port = Number.parseInt(urlTokens.port, 10);
+    }
+    let authorization = null;
+    if (urlTokens.username && urlTokens.password) {
+        authorization = urlTokens.username + ':' + urlTokens.password;
+    }
+    else if (urlTokens.username) {
+        authorization = urlTokens.username;
+    }
+    return {
+        authorization,
+        hostname: urlTokens.hostname,
+        port,
+    };
+};

package/dist/utilities/parseProxyUrl.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/parseProxyUrl.test.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const parseProxyUrl_1 = __importDefault(require("./parseProxyUrl"));
+(0, vitest_1.test)('extracts hostname', () => {
+    (0, vitest_1.expect)((0, parseProxyUrl_1.default)('http://0.0.0.0').hostname).toBe('0.0.0.0');
+});
+(0, vitest_1.test)('extracts port', () => {
+    (0, vitest_1.expect)((0, parseProxyUrl_1.default)('http://0.0.0.0:3000').port).toBe(3000);
+});
+(0, vitest_1.test)('extracts authorization', () => {
+    (0, vitest_1.expect)((0, parseProxyUrl_1.default)('http://foo:bar@0.0.0.0').authorization).toBe('foo:bar');
+});
+(0, vitest_1.test)('throws an error if protocol is not "http:"', () => {
+    (0, vitest_1.expect)(() => {
+        (0, parseProxyUrl_1.default)('https://0.0.0.0:3000');
+    }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL protocol must be "http:".');
+});
+(0, vitest_1.test)('throws an error if query is present', () => {
+    (0, vitest_1.expect)(() => {
+        (0, parseProxyUrl_1.default)('http://0.0.0.0:3000/?foo=bar');
+    }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have query.');
+});
+(0, vitest_1.test)('throws an error if hash is present', () => {
+    (0, vitest_1.expect)(() => {
+        (0, parseProxyUrl_1.default)('http://0.0.0.0:3000/#foo');
+    }).toThrow('Unsupported `GLOBAL_AGENT.HTTP_PROXY` configuration value: URL must not have hash.');
+});

package/package.json

@@ -41,6 +41,9 @@
     "typescript": "^4.3.5",
     "vitest": "^4.0.18"
   },
+  "files": [
+    "dist"
+  ],
   "engines": {
     "node": ">=10.0"
   },
@@ -56,7 +59,7 @@
     "agent"
   ],
   "license": "BSD-3-Clause",
-  "main": "./dist/src/index.js",
+  "main": "./dist/index.js",
   "name": "global-agent",
   "repository": {
     "type": "git",
@@ -69,5 +72,5 @@
     "create-readme": "gitdown ./.README/README.md --output-file ./README.md"
   },
   "typings": "./dist/src/index.d.ts",
-  "version": "4.1.2"
+  "version": "4.1.3"
 }

package/.babelrc

@@ -1,23 +0,0 @@
-{
-  "env": {
-    "test": {
-      "plugins": [
-        "istanbul"
-      ]
-    }
-  },
-  "plugins": [
-    "transform-export-default-name",
-    "@babel/transform-flow-strip-types"
-  ],
-  "presets": [
-    [
-      "@babel/env",
-      {
-        "targets": {
-          "node": "12"
-        }
-      }
-    ]
-  ]
-}

package/.editorconfig

@@ -1,9 +0,0 @@
-root = true
-
-[*]
-charset = utf-8
-end_of_line = lf
-indent_size = 2
-indent_style = space
-insert_final_newline = true
-trim_trailing_whitespace = true

package/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: gajus
-patreon: gajus

package/.github/workflows/feature.yaml

@@ -1,35 +0,0 @@
-jobs:
-  test:
-    name: Test (Node ${{ matrix.node-version }})
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: ['20', '22', '24']
-    steps:
-      - name: setup repository
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: setup node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: setup npm
-        uses: npm/action-setup@v4
-        with:
-          version: 10
-      - run: npm install
-      - run: npm run lint
-      - run: npm run test
-      - run: npm run build
-    timeout-minutes: 10
-name: Test
-on:
-  pull_request:
-    branches:
-      - main
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review

package/.github/workflows/main.yaml

@@ -1,50 +0,0 @@
-jobs:
-  test:
-    name: Test (Node ${{ matrix.node-version }})
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: ['20', '22', '24']
-    steps:
-      - name: setup repository
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: setup node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-      - run: npm install
-      - run: npm run lint
-      - run: npm run test
-      - run: npm run build
-    timeout-minutes: 10
-  release:
-    needs: test
-    environment: release
-    name: Release
-    permissions:
-      contents: write
-      id-token: write
-      issues: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: setup repository
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: setup node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: '24'
-      - run: npm install
-      - run: npm run build
-      - env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: npx semantic-release
-name: Release
-on:
-  push:
-    branches:
-      - main

package/.gitignore

@@ -1,12 +0,0 @@
-coverage
-dist
-node_modules
-*.log
-.*
-!.babelrc
-!.editorconfig
-!.github
-!.gitignore
-!.npmignore
-!.npmrc
-!.README

package/bootstrap.js

@@ -1 +0,0 @@
-require('./dist/index').bootstrap();

package/src/Logger.ts

@@ -1,70 +0,0 @@
-export type LogMethod = (context: object | string, message?: string) => void;
-
-export type Logger = {
-  child: (context: object) => Logger,
-  debug: LogMethod,
-  error: LogMethod,
-  info: LogMethod,
-  trace: LogMethod,
-  warn: LogMethod,
-};
-
-// oxlint-disable-next-line @typescript-eslint/no-empty-function
-const noop = () => {};
-
-const createNoopLogger = (): Logger => {
-  return {
-    child: () => {
-      return createNoopLogger();
-    },
-    debug: noop,
-    error: noop,
-    info: noop,
-    trace: noop,
-    warn: noop,
-  };
-};
-
-let currentLogger: Logger = createNoopLogger();
-
-export const setLogger = (newLogger: Logger): void => {
-  currentLogger = newLogger;
-};
-
-const createDelegatingLogger = (getContext: () => object): Logger => {
-  const getLogger = () => {
-    let targetLogger = currentLogger;
-    for (const [key, value] of Object.entries(getContext())) {
-      targetLogger = targetLogger.child({[key]: value});
-    }
-
-    return targetLogger;
-  };
-
-  return {
-    child: (context: object) => {
-      return createDelegatingLogger(() => {
-        return {...getContext(), ...context};
-      });
-    },
-    debug: (context, message) => {
-      getLogger().debug(context, message);
-    },
-    error: (context, message) => {
-      getLogger().error(context, message);
-    },
-    info: (context, message) => {
-      getLogger().info(context, message);
-    },
-    trace: (context, message) => {
-      getLogger().trace(context, message);
-    },
-    warn: (context, message) => {
-      getLogger().warn(context, message);
-    },
-  };
-};
-
-export const logger = createDelegatingLogger(() => {
-  return {package: 'global-agent'};
-});