WIP

Author: addaleax

packages/devtools-proxy-support/src/agent.ts

@@ -18,6 +18,7 @@ export type AgentWithInitialize = Agent & {
   // first before starting to push connections through it)
   initialize?(): Promise<void>;
   logger?: ProxyLogEmitter;
+  readonly proxyOptions?: Readonly<DevtoolsProxyOptions>;
 
   // This is just part of the regular Agent interface, used by Node.js itself,
   // but missing from @types/node
@@ -40,10 +41,13 @@ export function createAgent(
     return new SSHAgent(proxyOptions);
   }
   const getProxyForUrl = proxyForUrl(proxyOptions);
-  return new ProxyAgent({
-    getProxyForUrl,
-    ...proxyOptions,
-  });
+  return Object.assign(
+    new ProxyAgent({
+      getProxyForUrl,
+      ...proxyOptions,
+    }),
+    { proxyOptions }
+  );
 }
 
 export function useOrCreateAgent(

packages/devtools-proxy-support/src/index.ts

@@ -6,7 +6,7 @@ export {
   mergeProxySecrets,
 } from './proxy-options';
 export { Tunnel, TunnelOptions, setupSocks5Tunnel } from './socks5';
-export { createAgent } from './agent';
+export { createAgent, useOrCreateAgent, AgentWithInitialize } from './agent';
 export {
   createFetch,
   Request,

packages/devtools-proxy-support/src/logging.ts

@@ -74,12 +74,18 @@ interface MongoLogWriter {
   mongoLogId(this: void, id: number): unknown;
 }
 
+let alreadyHooked: WeakMap<ProxyLogEmitter, WeakSet<MongoLogWriter>>;
 let idCounter = 0;
 export function hookLogger(
   emitter: ProxyLogEmitter,
   logCtx: string,
   log: MongoLogWriter
 ): void {
+  // This helps avoid unintentionally attaching the same logging twice in devtools-connet
+  if (alreadyHooked.get(emitter)?.has(log)) return;
+  if (!alreadyHooked.has(emitter)) alreadyHooked.set(emitter, new WeakSet());
+  alreadyHooked.get(emitter)!.add(log);
+
   logCtx = `${logCtx}-${idCounter++}`;
   const { mongoLogId } = log;
 

packages/devtools-proxy-support/src/proxy-options.ts

@@ -1,4 +1,5 @@
 import type { ConnectionOptions } from 'tls';
+import type { TunnelOptions } from './socks5';
 
 // Should be an opaque type, but TS does not support those.
 export type DevtoolsProxyOptionsSecrets = string;
@@ -216,6 +217,27 @@ export function translateToElectronProxyConfig(
   return {};
 }
 
+// Return the Socks5 tunnel configuration, if proxyOptions always resolves to one.
+// This is used by setupSocks5Tunnel() to avoid creating a local Socks5 tunnel
+// that would just forward to another Socks5 tunnel anyway.
+export function getSocks5OnlyProxyOptions(
+  proxyOptions: DevtoolsProxyOptions,
+  target?: string
+): TunnelOptions | undefined {
+  let proxyUrl: string | undefined;
+  if (target !== undefined) proxyUrl = proxyForUrl(proxyOptions)(target);
+  else if (!proxyOptions.noProxyHosts) proxyUrl = proxyOptions.proxy;
+  if (!proxyUrl) return undefined;
+  const url = new URL(proxyUrl);
+  if (url.protocol !== 'socks5:') return undefined;
+  return {
+    proxyHost: decodeURIComponent(url.hostname),
+    proxyPort: +(url.port || 1080),
+    proxyUsername: decodeURIComponent(url.username) || undefined,
+    proxyPassword: decodeURIComponent(url.password) || undefined,
+  };
+}
+
 interface DevtoolsProxyOptionsSecretsInternal {
   username?: string;
   password?: string;

packages/devtools-proxy-support/src/socks5.spec.ts

@@ -1,9 +1,10 @@
 import sinon from 'sinon';
 import { HTTPServerProxyTestSetup } from '../test/helpers';
-import type { Tunnel } from './socks5';
+import type { Tunnel, TunnelOptions } from './socks5';
 import { setupSocks5Tunnel } from './socks5';
 import { expect } from 'chai';
 import { createFetch } from './fetch';
+import type { DevtoolsProxyOptions } from './proxy-options';
 
 describe('setupSocks5Tunnel', function () {
   let setup: HTTPServerProxyTestSetup;
@@ -97,4 +98,45 @@ describe('setupSocks5Tunnel', function () {
       expect(err.code).to.equal('EADDRNOTAVAIL');
     }
   });
+
+  it('does not start an actual server if the proxy config already specifies socks5', async function () {
+    async function existingTunnelConfig(
+      options: DevtoolsProxyOptions,
+      target?: string
+    ): Promise<TunnelOptions | undefined> {
+      const tunnel = await setupSocks5Tunnel(options, undefined, target);
+      expect(tunnel?.constructor.name).to.equal('ExistingTunnel');
+      return JSON.parse(JSON.stringify(tunnel?.config)); // filter out undefined values
+    }
+
+    expect(
+      await existingTunnelConfig({ proxy: 'socks5://example.com:123' })
+    ).to.deep.equal({ proxyHost: 'example.com', proxyPort: 123 });
+    expect(
+      await existingTunnelConfig({ proxy: 'socks5://example.com' })
+    ).to.deep.equal({ proxyHost: 'example.com', proxyPort: 1080 });
+    expect(
+      await existingTunnelConfig({ proxy: 'socks5://foo:[email protected]' })
+    ).to.deep.equal({
+      proxyHost: 'example.com',
+      proxyPort: 1080,
+      proxyUsername: 'foo',
+      proxyPassword: 'bar',
+    });
+    expect(
+      await existingTunnelConfig(
+        { proxy: 'socks5://example.com:123' },
+        'mongodb://'
+      )
+    ).to.deep.equal({ proxyHost: 'example.com', proxyPort: 123 });
+    expect(
+      await existingTunnelConfig(
+        {
+          useEnvironmentVariableProxies: true,
+          env: { MONGODB_PROXY: 'socks5://example.com:123' },
+        },
+        'mongodb://'
+      )
+    ).to.deep.equal({ proxyHost: 'example.com', proxyPort: 123 });
+  });
 });

packages/devtools-proxy-support/src/socks5.ts

@@ -1,4 +1,5 @@
 import { EventEmitter, once } from 'events';
+import { getSocks5OnlyProxyOptions } from './proxy-options';
 import type { DevtoolsProxyOptions } from './proxy-options';
 import type { AgentWithInitialize } from './agent';
 import { useOrCreateAgent } from './agent';
@@ -287,11 +288,35 @@ class Socks5Server extends EventEmitter implements Tunnel {
   }
 }
 
+class ExistingTunnel extends EventEmitter {
+  logger = new EventEmitter();
+  readonly config: TunnelOptions;
+
+  constructor(config: TunnelOptions) {
+    super();
+    this.config = config;
+  }
+
+  async close() {
+    // nothing to do if we didn't start a server
+  }
+}
+
 export async function setupSocks5Tunnel(
   proxyOptions: DevtoolsProxyOptions | AgentWithInitialize,
   tunnelOptions?: Partial<TunnelOptions>,
   target?: string | undefined
 ): Promise<Tunnel | undefined> {
+  const socks5OnlyProxyOptions = getSocks5OnlyProxyOptions(
+    ('proxyOptions' in proxyOptions
+      ? proxyOptions.proxyOptions
+      : proxyOptions) as DevtoolsProxyOptions,
+    target
+  );
+  if (socks5OnlyProxyOptions) {
+    return new ExistingTunnel(socks5OnlyProxyOptions);
+  }
+
   const agent = useOrCreateAgent(proxyOptions, target);
   if (!agent) return undefined;
 

packages/devtools-proxy-support/src/ssh.ts

@@ -17,7 +17,7 @@ import type { Socket } from 'net';
 // https://github.com/mongodb-js/compass/tree/55a5a608713d7316d158dc66febeb6b114d8b40d/packages/ssh-tunnel/src
 export class SSHAgent extends AgentBase implements AgentWithInitialize {
   public logger: ProxyLogEmitter;
-  private readonly proxyOptions: Readonly<DevtoolsProxyOptions>;
+  public readonly proxyOptions: Readonly<DevtoolsProxyOptions>;
   private readonly url: URL;
   private sshClient: SshClient;
   private connected = false;