@openclaw/proxyline 0.2.0 → 0.3.1

package/src/shared.ts

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+
+export type ProxylineTlsOptions = Readonly<{
+  ca?: string;
+  caFile?: string;
+}>;
+
+export class ProxylineError extends Error {
+  public readonly code: string;
+
+  public constructor(code: string, message: string) {
+    super(message);
+    this.name = "ProxylineError";
+    this.code = code;
+  }
+}
+
+export function resolveProxyTlsCa(options: ProxylineTlsOptions | undefined): string | undefined {
+  if (!options) {
+    return undefined;
+  }
+  if (options.ca !== undefined) {
+    return options.ca;
+  }
+  if (options.caFile !== undefined) {
+    return fs.readFileSync(options.caFile, "utf8");
+  }
+  return undefined;
+}
+
+export function formatUrl(value: string | URL): string {
+  return value instanceof URL ? value.href : new URL(value).href;
+}
+
+export function redactProxyUrl(value: string | URL): string {
+  const url = value instanceof URL ? new URL(value.href) : new URL(value);
+  url.username = "";
+  url.password = "";
+  url.search = "";
+  url.hash = "";
+  return url.href;
+}

package/src/types.ts

@@ -0,0 +1,98 @@
+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;
+  ifActive?: "error" | "reuse-compatible" | "replace";
+  onEvent?: (event: ProxylineEvent) => void;
+  undici?: ProxylineUndiciOptions;
+}>;
+
+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 ProxylineBypassRegistration = Readonly<{
+  surface?: ProxylineSurface;
+  url: string | URL;
+}>;
+
+export type ProxylineUndiciOptions = Readonly<{
+  allowH2?: boolean;
+  bodyTimeout?: number;
+  headersTimeout?: number;
+  connect?: Readonly<{
+    autoSelectFamily?: boolean;
+    autoSelectFamilyAttemptTimeout?: number;
+  }>;
+}>;
+
+export type ProxylineHandle = Readonly<{
+  mode: ProxylineMode;
+  active: boolean;
+  proxyUrl?: string;
+  createNodeAgent: () => HttpAgent;
+  createUndiciDispatcher: () => Dispatcher;
+  createWebSocketAgent: () => HttpAgent;
+  explain: (url: string | URL, options?: ExplainOptions) => ProxylineDecision;
+  registerBypass: (registration: ProxylineBypassRegistration) => () => void;
+  stop: () => void;
+  withBypass: <T>(registration: ProxylineBypassRegistration, run: () => T) => T;
+}>;
+
+export type ProxyResolver = Readonly<{
+  active: boolean;
+  describeProxy: () => string | undefined;
+  explain: (url: string | URL, surface: ProxylineSurface) => ProxylineDecision;
+  getProxyForUrl: (url: string, surface?: ProxylineSurface) => string;
+}>;

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "exactOptionalPropertyTypes": true,
+    "lib": ["ES2022"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "noEmit": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUncheckedIndexedAccess": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022"
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}