@openclaw/proxyline 0.1.0 → 0.2.0

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAGV,eAAe,EACf,gBAAgB,EAGjB,MAAM,YAAY,CAAC;AA6kBpB,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,eAAe,CAqF3E;AAED,eAAO,MAAM,kBAAkB,yBAAmB,CAAC"}

package/dist/runtime.js

@@ -0,0 +1,512 @@
+import http from "node:http";
+import https from "node:https";
+import { Agent as UndiciAgent, Dispatcher, FormData as UndiciFormData, Headers as UndiciHeaders, Request as UndiciRequest, Response as UndiciResponse, errors as undiciErrors, fetch as undiciFetch, getGlobalDispatcher, ProxyAgent as UndiciProxyAgent, setGlobalDispatcher, } from "undici";
+import { createAmbientProxyResolver, EMPTY_PROXY_ENV, resolveAmbientProxyForUrl, readProxyEnv, } from "./env.js";
+import { bindNodeHttpMethod, createDirectNodeAgent, createNodeProxyAgent, } from "./node-http.js";
+import { formatUrl, ProxylineError, redactProxyUrl, resolveProxyTlsCa, } from "./shared.js";
+let activeRuntime;
+// Node's global fetch types come from bundled undici-types, while the runtime
+// implementation intentionally delegates to this package's undici dependency.
+const proxylineHeaders = UndiciHeaders;
+const proxylineRequest = UndiciRequest;
+const proxylineResponse = UndiciResponse;
+const proxylineFormData = UndiciFormData;
+function getRequestDispatcher(request) {
+    for (const symbol of Object.getOwnPropertySymbols(request)) {
+        if (symbol.description !== "dispatcher") {
+            continue;
+        }
+        return Reflect.get(request, symbol);
+    }
+    return undefined;
+}
+function isFetchRequestLike(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = value;
+    return (typeof record.url === "string" &&
+        typeof record.method === "string" &&
+        typeof record.arrayBuffer === "function" &&
+        record.headers !== undefined);
+}
+async function createProxylineRequestFromRequestLike(request, options) {
+    const init = {
+        headers: request.headers,
+        method: request.method,
+    };
+    if (request.cache !== undefined) {
+        init.cache = request.cache;
+    }
+    if (request.credentials !== undefined) {
+        init.credentials = request.credentials;
+    }
+    if (request.integrity !== undefined) {
+        init.integrity = request.integrity;
+    }
+    if (request.keepalive !== undefined) {
+        init.keepalive = request.keepalive;
+    }
+    if (request.mode !== undefined) {
+        init.mode = request.mode;
+    }
+    if (request.redirect !== undefined) {
+        init.redirect = request.redirect;
+    }
+    if (request.referrer !== undefined) {
+        init.referrer = request.referrer;
+    }
+    if (request.referrerPolicy !== undefined) {
+        init.referrerPolicy = request.referrerPolicy;
+    }
+    if (options.preserveDispatcher) {
+        const dispatcher = getRequestDispatcher(request);
+        if (dispatcher !== undefined) {
+            Reflect.set(init, "dispatcher", dispatcher);
+        }
+    }
+    if (request.signal !== undefined) {
+        init.signal = request.signal;
+    }
+    if (options.includeBody &&
+        request.body !== null &&
+        request.method !== "GET" &&
+        request.method !== "HEAD") {
+        init.body = request.body;
+        init.duplex = "half";
+    }
+    const requestUnknown = Reflect.construct(proxylineRequest, [request.url, init]);
+    if (!(requestUnknown instanceof proxylineRequest)) {
+        throw new TypeError("Proxyline failed to normalize a fetch Request.");
+    }
+    return requestUnknown;
+}
+function requestInitOverridesBody(init) {
+    if (typeof init !== "object" || init === null) {
+        return false;
+    }
+    return "body" in init;
+}
+async function normalizeFetchInput(input, init, options) {
+    if ((input instanceof proxylineRequest && options.preserveDispatcher) || !isFetchRequestLike(input)) {
+        return input;
+    }
+    return await createProxylineRequestFromRequestLike(input, {
+        includeBody: !requestInitOverridesBody(init),
+        preserveDispatcher: options.preserveDispatcher,
+    });
+}
+function stripFetchDispatcher(init) {
+    if (typeof init !== "object" || init === null) {
+        return init;
+    }
+    const sanitized = Object.create(init);
+    Reflect.defineProperty(sanitized, "dispatcher", {
+        configurable: true,
+        enumerable: true,
+        value: undefined,
+        writable: true,
+    });
+    return sanitized;
+}
+const proxylineFetch = async (input, init) => {
+    const managedMode = activeRuntime?.mode === "managed";
+    const normalizedInput = await normalizeFetchInput(input, init, {
+        preserveDispatcher: !managedMode,
+    });
+    const normalizedInit = managedMode ? stripFetchDispatcher(init) : init;
+    const response = await Reflect.apply(undiciFetch, undefined, normalizedInit === undefined ? [normalizedInput] : [normalizedInput, normalizedInit]);
+    if (!(response instanceof proxylineResponse)) {
+        throw new TypeError("Proxyline fetch returned a non-Response value.");
+    }
+    return response;
+};
+function normalizeProxyUrl(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const url = value instanceof URL ? new URL(value.href) : new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new ProxylineError("UNSUPPORTED_PROXY_PROTOCOL", `Proxyline only supports http:// and https:// proxy endpoints in this slice: ${url.protocol}`);
+    }
+    return url;
+}
+function emit(onEvent, event) {
+    onEvent?.(event);
+}
+function isProxyableUrlProtocol(protocol) {
+    return protocol === "http:" ||
+        protocol === "https:" ||
+        protocol === "ws:" ||
+        protocol === "wss:";
+}
+function shouldBypassManagedProxy(bypassPolicy, url, surface) {
+    if (bypassPolicy === undefined) {
+        return false;
+    }
+    return bypassPolicy({ surface, url: formatUrl(url) });
+}
+function createManagedProxyResolver(proxyUrl, bypassPolicy) {
+    const redactedProxyUrl = redactProxyUrl(proxyUrl);
+    return {
+        active: true,
+        describeProxy: () => redactedProxyUrl,
+        explain: (url, surface) => {
+            const formattedUrl = formatUrl(url);
+            if (!isProxyableUrlProtocol(new URL(url).protocol)) {
+                return {
+                    kind: "direct",
+                    reason: "managed-proxy-unsupported-url-scheme",
+                    surface,
+                    url: formattedUrl,
+                };
+            }
+            if (shouldBypassManagedProxy(bypassPolicy, url, surface)) {
+                return {
+                    kind: "direct",
+                    reason: "managed-proxy-bypass-policy",
+                    surface,
+                    url: formattedUrl,
+                };
+            }
+            return {
+                kind: "proxied",
+                reason: "managed-proxy-active",
+                surface,
+                url: formattedUrl,
+                proxyUrl: redactedProxyUrl,
+            };
+        },
+        getProxyForUrl: (url) => {
+            const protocol = new URL(url).protocol;
+            return isProxyableUrlProtocol(protocol) &&
+                !shouldBypassManagedProxy(bypassPolicy, url, "unknown")
+                ? proxyUrl.href
+                : "";
+        },
+    };
+}
+function createUndiciProxyDispatcher(options, proxyCa) {
+    if (options.mode === "ambient") {
+        if (!options.active) {
+            return new UndiciAgent();
+        }
+        return new AmbientUndiciDispatcher(options.env, proxyCa);
+    }
+    return new ManagedUndiciDispatcher(options.resolver, proxyCa);
+}
+class ManagedUndiciDispatcher extends Dispatcher {
+    #directDispatcher = new UndiciAgent();
+    #proxyCa;
+    #proxyDispatchers = new Map();
+    #resolver;
+    #closedError;
+    constructor(resolver, proxyCa) {
+        super();
+        this.#resolver = resolver;
+        this.#proxyCa = proxyCa;
+    }
+    dispatch(options, handler) {
+        if (this.#closedError !== undefined) {
+            if (handler.onError === undefined) {
+                throw this.#closedError;
+            }
+            handler.onError(this.#closedError);
+            return false;
+        }
+        const url = resolveUndiciDispatchUrl(options);
+        const proxyUrl = url === undefined ? "" : this.#resolver.getProxyForUrl(url);
+        const dispatcher = proxyUrl === "" ? this.#directDispatcher : this.#proxyDispatcher(proxyUrl);
+        return dispatcher.dispatch(options, handler);
+    }
+    close(callback) {
+        const closing = this.#closeAll();
+        if (callback === undefined) {
+            return closing;
+        }
+        closing.then(callback, callback);
+    }
+    destroy(errorOrCallback, callback) {
+        const error = typeof errorOrCallback === "function" ? null : errorOrCallback ?? null;
+        const destroyCallback = typeof errorOrCallback === "function" ? errorOrCallback : callback;
+        const destroying = this.#destroyAll(error);
+        if (destroyCallback === undefined) {
+            return destroying;
+        }
+        destroying.then(destroyCallback, destroyCallback);
+    }
+    #proxyDispatcher(proxyUrl) {
+        const existing = this.#proxyDispatchers.get(proxyUrl);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const dispatcher = new UndiciProxyAgent({
+            uri: proxyUrl,
+            ...(this.#proxyCa !== undefined ? { proxyTls: { ca: this.#proxyCa } } : {}),
+        });
+        this.#proxyDispatchers.set(proxyUrl, dispatcher);
+        return dispatcher;
+    }
+    async #closeAll() {
+        this.#closedError ??= new undiciErrors.ClientClosedError();
+        const proxyDispatchers = [...this.#proxyDispatchers.values()];
+        this.#proxyDispatchers.clear();
+        await Promise.all([
+            this.#directDispatcher.close(),
+            ...proxyDispatchers.map((dispatcher) => dispatcher.close()),
+        ]);
+    }
+    async #destroyAll(error) {
+        this.#closedError ??= error ?? new undiciErrors.ClientDestroyedError();
+        const proxyDispatchers = [...this.#proxyDispatchers.values()];
+        this.#proxyDispatchers.clear();
+        await Promise.all([
+            this.#directDispatcher.destroy(error),
+            ...proxyDispatchers.map((dispatcher) => dispatcher.destroy(error)),
+        ]);
+    }
+}
+class AmbientUndiciDispatcher extends Dispatcher {
+    #directDispatcher = new UndiciAgent();
+    #env;
+    #proxyCa;
+    #proxyDispatchers = new Map();
+    #closedError;
+    constructor(env, proxyCa) {
+        super();
+        this.#env = env;
+        this.#proxyCa = proxyCa;
+    }
+    dispatch(options, handler) {
+        if (this.#closedError !== undefined) {
+            if (handler.onError === undefined) {
+                throw this.#closedError;
+            }
+            handler.onError(this.#closedError);
+            return false;
+        }
+        const url = resolveUndiciDispatchUrl(options);
+        const proxyUrl = url === undefined ? undefined : resolveAmbientProxyForUrl(url, this.#env);
+        const dispatcher = proxyUrl === undefined ? this.#directDispatcher : this.#proxyDispatcher(proxyUrl);
+        return dispatcher.dispatch(options, handler);
+    }
+    close(callback) {
+        const closing = this.#closeAll();
+        if (callback === undefined) {
+            return closing;
+        }
+        closing.then(callback, callback);
+    }
+    destroy(errorOrCallback, callback) {
+        const error = typeof errorOrCallback === "function" ? null : errorOrCallback ?? null;
+        const destroyCallback = typeof errorOrCallback === "function" ? errorOrCallback : callback;
+        const destroying = this.#destroyAll(error);
+        if (destroyCallback === undefined) {
+            return destroying;
+        }
+        destroying.then(destroyCallback, destroyCallback);
+    }
+    #proxyDispatcher(proxyUrl) {
+        const existing = this.#proxyDispatchers.get(proxyUrl);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const dispatcher = new UndiciProxyAgent({
+            uri: proxyUrl,
+            ...(this.#proxyCa !== undefined ? { proxyTls: { ca: this.#proxyCa } } : {}),
+        });
+        this.#proxyDispatchers.set(proxyUrl, dispatcher);
+        return dispatcher;
+    }
+    async #closeAll() {
+        this.#closedError ??= new undiciErrors.ClientClosedError();
+        const proxyDispatchers = [...this.#proxyDispatchers.values()];
+        this.#proxyDispatchers.clear();
+        await Promise.all([
+            this.#directDispatcher.close(),
+            ...proxyDispatchers.map((dispatcher) => dispatcher.close()),
+        ]);
+    }
+    async #destroyAll(error) {
+        this.#closedError ??= error ?? new undiciErrors.ClientDestroyedError();
+        const proxyDispatchers = [...this.#proxyDispatchers.values()];
+        this.#proxyDispatchers.clear();
+        await Promise.all([
+            this.#directDispatcher.destroy(error),
+            ...proxyDispatchers.map((dispatcher) => dispatcher.destroy(error)),
+        ]);
+    }
+}
+function resolveUndiciDispatchUrl(options) {
+    if (options.origin !== undefined) {
+        const origin = options.origin.toString().replace(/\/$/, "");
+        const path = options.path.startsWith("/") ? options.path : `/${options.path}`;
+        return new URL(`${origin}${path}`).href;
+    }
+    try {
+        return new URL(options.path).href;
+    }
+    catch {
+        return undefined;
+    }
+}
+function restoreNodeHttpSnapshot(snapshot) {
+    http.request = snapshot.httpRequest;
+    http.get = snapshot.httpGet;
+    http.globalAgent = snapshot.httpGlobalAgent;
+    https.request = snapshot.httpsRequest;
+    https.get = snapshot.httpsGet;
+    https.globalAgent = snapshot.httpsGlobalAgent;
+}
+function installRuntime(resolver, dispatcherOptions, proxyCa) {
+    if (activeRuntime !== undefined) {
+        throw new ProxylineError("RUNTIME_ALREADY_ACTIVE", "Proxyline already has an active runtime.");
+    }
+    const snapshot = {
+        httpRequest: http.request,
+        httpGet: http.get,
+        httpGlobalAgent: http.globalAgent,
+        httpsRequest: https.request,
+        httpsGet: https.get,
+        httpsGlobalAgent: https.globalAgent,
+    };
+    const nodeHttpAgent = createNodeProxyAgent(resolver, proxyCa, "http");
+    const nodeHttpsAgent = createNodeProxyAgent(resolver, proxyCa, "https");
+    const originalDispatcher = getGlobalDispatcher();
+    const originalFetch = globalThis.fetch;
+    const originalFormData = globalThis.FormData;
+    const originalHeaders = globalThis.Headers;
+    const originalRequest = globalThis.Request;
+    const originalResponse = globalThis.Response;
+    const installedDispatcher = createUndiciProxyDispatcher(dispatcherOptions, proxyCa);
+    const runtime = {
+        installedDispatcher,
+        mode: dispatcherOptions.mode,
+        nodeHttpAgent,
+        nodeHttpsAgent,
+        originalDispatcher,
+        originalFetch,
+        originalFormData,
+        originalHeaders,
+        originalRequest,
+        originalResponse,
+        snapshot,
+    };
+    activeRuntime = runtime;
+    try {
+        http.globalAgent = nodeHttpAgent;
+        https.globalAgent = nodeHttpsAgent;
+        http.request = bindNodeHttpMethod(snapshot.httpRequest, () => createNodeProxyAgent(resolver, proxyCa, "http"));
+        http.get = bindNodeHttpMethod(snapshot.httpGet, () => createNodeProxyAgent(resolver, proxyCa, "http"));
+        https.request = bindNodeHttpMethod(snapshot.httpsRequest, () => createNodeProxyAgent(resolver, proxyCa, "https"));
+        https.get = bindNodeHttpMethod(snapshot.httpsGet, () => createNodeProxyAgent(resolver, proxyCa, "https"));
+        setGlobalDispatcher(installedDispatcher);
+        globalThis.fetch = proxylineFetch;
+        globalThis.FormData = proxylineFormData;
+        globalThis.Headers = proxylineHeaders;
+        globalThis.Request = proxylineRequest;
+        globalThis.Response = proxylineResponse;
+    }
+    catch (error) {
+        restoreNodeHttpSnapshot(snapshot);
+        setGlobalDispatcher(originalDispatcher);
+        globalThis.fetch = originalFetch;
+        globalThis.FormData = originalFormData;
+        globalThis.Headers = originalHeaders;
+        globalThis.Request = originalRequest;
+        globalThis.Response = originalResponse;
+        activeRuntime = undefined;
+        void installedDispatcher.destroy();
+        nodeHttpAgent.destroy();
+        nodeHttpsAgent.destroy();
+        throw error;
+    }
+    return runtime;
+}
+function stopRuntime(runtime) {
+    if (activeRuntime !== runtime) {
+        return;
+    }
+    restoreNodeHttpSnapshot(runtime.snapshot);
+    setGlobalDispatcher(runtime.originalDispatcher);
+    globalThis.fetch = runtime.originalFetch;
+    globalThis.FormData = runtime.originalFormData;
+    globalThis.Headers = runtime.originalHeaders;
+    globalThis.Request = runtime.originalRequest;
+    globalThis.Response = runtime.originalResponse;
+    void runtime.installedDispatcher.destroy();
+    runtime.nodeHttpAgent.destroy();
+    runtime.nodeHttpsAgent.destroy();
+    activeRuntime = undefined;
+}
+export function installProxyline(options) {
+    const proxyUrl = options.mode === "managed" ? normalizeProxyUrl(options.proxyUrl) : undefined;
+    if (options.mode === "managed" && proxyUrl === undefined) {
+        throw new ProxylineError("MANAGED_PROXY_URL_REQUIRED", "Proxyline managed mode requires an explicit proxyUrl.");
+    }
+    let stopped = false;
+    const proxyCa = resolveProxyTlsCa(options.proxyTls);
+    const ambientEnv = proxyUrl === undefined ? readProxyEnv() : undefined;
+    const resolver = proxyUrl !== undefined
+        ? createManagedProxyResolver(proxyUrl, options.bypassPolicy)
+        : createAmbientProxyResolver(ambientEnv ?? EMPTY_PROXY_ENV);
+    const redactedProxyUrl = resolver.describeProxy();
+    const hasActiveProxy = resolver.active;
+    const runtime = hasActiveProxy
+        ? installRuntime(resolver, proxyUrl !== undefined
+            ? { mode: "managed", resolver }
+            : { mode: "ambient", env: ambientEnv ?? EMPTY_PROXY_ENV, active: hasActiveProxy }, proxyCa)
+        : undefined;
+    emit(options.onEvent, {
+        type: "runtime.installed",
+        mode: options.mode,
+        active: hasActiveProxy,
+        ...(redactedProxyUrl ? { proxyUrl: redactedProxyUrl } : {}),
+    });
+    const handle = {
+        mode: options.mode,
+        active: hasActiveProxy,
+        ...(redactedProxyUrl ? { proxyUrl: redactedProxyUrl } : {}),
+        createNodeAgent: () => {
+            if (!hasActiveProxy || stopped) {
+                return createDirectNodeAgent();
+            }
+            return createNodeProxyAgent(resolver, proxyCa);
+        },
+        createUndiciDispatcher: () => stopped
+            ? new UndiciAgent()
+            : createUndiciProxyDispatcher(proxyUrl !== undefined
+                ? { mode: "managed", resolver }
+                : { mode: "ambient", env: ambientEnv ?? EMPTY_PROXY_ENV, active: hasActiveProxy }, proxyCa),
+        createWebSocketAgent: () => {
+            if (!hasActiveProxy || stopped) {
+                return createDirectNodeAgent();
+            }
+            return createNodeProxyAgent(resolver, proxyCa);
+        },
+        explain: (url, explainOptions) => {
+            const decision = stopped
+                ? {
+                    kind: "direct",
+                    reason: "runtime-stopped",
+                    surface: explainOptions?.surface ?? "unknown",
+                    url: formatUrl(url),
+                }
+                : resolver.explain(url, explainOptions?.surface ?? "unknown");
+            emit(options.onEvent, { type: "decision", decision });
+            return decision;
+        },
+        stop: () => {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            if (runtime !== undefined) {
+                stopRuntime(runtime);
+            }
+            emit(options.onEvent, { type: "runtime.stopped", mode: options.mode });
+        },
+    };
+    return handle;
+}
+export const installGlobalProxy = installProxyline;

package/dist/shared.d.ts

@@ -7,5 +7,6 @@ export declare class ProxylineError extends Error {
     constructor(code: string, message: string);
 }
 export declare function resolveProxyTlsCa(options: ProxylineTlsOptions | undefined): string | undefined;
+export declare function formatUrl(value: string | URL): string;
 export declare function redactProxyUrl(value: string | URL): string;
 //# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAEH,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAKjD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAW9F;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAO1D"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAEH,qBAAa,cAAe,SAAQ,KAAK;IACvC,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAKjD;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAW9F;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAErD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAO1D"}

package/dist/shared.js

@@ -19,6 +19,9 @@ export function resolveProxyTlsCa(options) {
     }
     return undefined;
 }
+export function formatUrl(value) {
+    return value instanceof URL ? value.href : new URL(value).href;
+}
 export function redactProxyUrl(value) {
     const url = value instanceof URL ? new URL(value.href) : new URL(value);
     url.username = "";

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+import type { Agent as HttpAgent } from "node:http";
+import type { Dispatcher } from "undici";
+import type { ProxylineTlsOptions } from "./shared.js";
+export type ProxylineMode = "managed" | "ambient";
+export type ProxylineSurface = "node-http" | "node-https" | "undici" | "websocket" | "connect" | "unknown";
+export type ProxylineOptions = Readonly<{
+    mode: ProxylineMode;
+    proxyUrl?: string | URL;
+    proxyTls?: ProxylineTlsOptions;
+    bypassPolicy?: ProxylineBypassPolicy;
+    onEvent?: (event: ProxylineEvent) => void;
+}>;
+export type ProxylineDecision = Readonly<{
+    kind: "proxied" | "direct" | "blocked";
+    reason: string;
+    surface: ProxylineSurface;
+    url: string;
+    proxyUrl?: string;
+}>;
+export type ProxylineBypassRequest = Readonly<{
+    surface: ProxylineSurface;
+    url: string;
+}>;
+export type ProxylineBypassPolicy = (request: ProxylineBypassRequest) => boolean;
+export type ProxylineEvent = Readonly<{
+    type: "runtime.installed";
+    mode: ProxylineMode;
+    active: boolean;
+    proxyUrl?: string;
+}> | Readonly<{
+    type: "runtime.stopped";
+    mode: ProxylineMode;
+}> | Readonly<{
+    type: "decision";
+    decision: ProxylineDecision;
+}> | Readonly<{
+    type: "warning";
+    code: string;
+    message: string;
+}>;
+export type ExplainOptions = Readonly<{
+    surface?: ProxylineSurface;
+}>;
+export type ProxylineHandle = Readonly<{
+    mode: ProxylineMode;
+    active: boolean;
+    proxyUrl?: string;
+    createNodeAgent: () => HttpAgent;
+    createUndiciDispatcher: () => Dispatcher;
+    createWebSocketAgent: () => HttpAgent;
+    explain: (url: string | URL, options?: ExplainOptions) => ProxylineDecision;
+    stop: () => void;
+}>;
+export type ProxyResolver = Readonly<{
+    active: boolean;
+    describeProxy: () => string | undefined;
+    explain: (url: string | URL, surface: ProxylineSurface) => ProxylineDecision;
+    getProxyForUrl: (url: string) => string;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/proxyline",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Process-global proxy routing for Node.js.",
   "type": "module",
   "license": "MIT",
@@ -17,6 +17,7 @@
     "url": "https://github.com/openclaw/proxyline/issues"
   },
   "homepage": "https://proxyline.dev",
+  "packageManager": "pnpm@10.33.2",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -31,27 +32,29 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "pnpm build && tsc --noEmit && pnpm coverage:run",
+    "coverage": "pnpm build && pnpm coverage:run",
+    "coverage:run": "node scripts/run-coverage.mjs",
+    "docs:build": "node scripts/build-docs-site.mjs",
+    "package:dry-run": "pnpm pack --dry-run",
+    "prepack": "node scripts/prepack-build.mjs",
+    "publish:dry-run": "pnpm publish --dry-run --access public",
+    "test": "pnpm build && tsx --test test/index.test.ts test/e2e.test.ts test/package.test.ts",
+    "typecheck": "pnpm build && tsc --noEmit"
+  },
   "devDependencies": {
-    "@types/node": "^20.19.25",
+    "@types/node": "^20.19.40",
     "@types/ws": "^8.18.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "ws": "^8.20.0"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=20.18.1"
   },
   "dependencies": {
-    "proxy-agent": "^8.0.1",
     "undici": "^7.25.0"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "check": "pnpm typecheck && pnpm test && pnpm build",
-    "docs:build": "node scripts/build-docs-site.mjs",
-    "package:dry-run": "pnpm pack --dry-run",
-    "publish:dry-run": "pnpm publish --dry-run --access public",
-    "test": "tsx --test test/index.test.ts test/e2e.test.ts",
-    "typecheck": "tsc --noEmit"
   }
-}
+}