fix: fixing usage of Host and Port types to be internal

[ci skip]

Author: tegefaulkes

package-lock.json

@@ -89,7 +89,7 @@
     "@matrixai/resources": "^1.1.5",
     "@matrixai/timer": "^1.1.1",
     "@matrixai/workers": "^1.3.7",
-    "@matrixai/quic": "^0.0.12",
+    "@matrixai/quic": "^0.0.13",
     "@peculiar/asn1-pkcs8": "^2.3.0",
     "@peculiar/asn1-schema": "^2.3.0",
     "@peculiar/asn1-x509": "^2.3.0",

package.json

@@ -49,12 +49,12 @@ import { serverManifest as agentServerManifest } from './agent/handlers';
 
 type NetworkConfig = {
   // Agent QUICSocket config
-  agentHost?: Host;
-  agentPort?: Port;
+  agentHost?: string;
+  agentPort?: number;
   ipv6Only?: boolean;
   // RPCServer for client service
-  clientHost?: Host;
-  clientPort?: Port;
+  clientHost?: string;
+  clientPort?: number;
   // Websocket server config
   maxReadableStreamBytes?: number;
   connectionIdleTimeoutTime?: number;
@@ -905,8 +905,8 @@ class PolykeyAgent {
           if (nodeId == null) throw Error('failed to extract NodeId from cert');
           const data: ConnectionData = {
             remoteNodeId: nodeId,
-            remoteHost: connection.remoteHost as unknown as Host,
-            remotePort: connection.remotePort as unknown as Port,
+            remoteHost: connection.remoteHost as Host,
+            remotePort: connection.remotePort as Port,
           };
           await this.events.emitAsync(
             PolykeyAgent.eventSymbols.QUICServer,
@@ -970,8 +970,8 @@ class PolykeyAgent {
         nodeId: this.keyRing.getNodeId(),
         clientHost: this.webSocketServerClient.getHost(),
         clientPort: this.webSocketServerClient.getPort(),
-        agentHost: this.quicSocket.host as unknown as Host,
-        agentPort: this.quicSocket.port as unknown as Port,
+        agentHost: this.quicSocket.host,
+        agentPort: this.quicSocket.port,
       });
       this.logger.info(`Started ${this.constructor.name}`);
     } catch (e) {

src/PolykeyAgent.ts

@@ -1,7 +1,6 @@
 import type { FileSystem } from '../../types';
 import type { RecoveryCode } from '../../keys/types';
 import type { NodeId } from '../../ids/types';
-import type { Host, Port } from '../../network/types';
 import type {
   StatusStarting,
   StatusLive,
@@ -203,14 +202,14 @@ async function processRecoveryCode(
 async function processClientOptions(
   nodePath: string,
   nodeId?: NodeId,
-  clientHost?: Host,
-  clientPort?: Port,
+  clientHost?: string,
+  clientPort?: number,
   fs = require('fs'),
   logger = new Logger(processClientOptions.name),
 ): Promise<{
   nodeId: NodeId;
-  clientHost: Host;
-  clientPort: Port;
+  clientHost: string;
+  clientPort: number;
 }> {
   if (nodeId != null && clientHost != null && clientPort != null) {
     return {
@@ -266,31 +265,31 @@ async function processClientOptions(
 async function processClientStatus(
   nodePath: string,
   nodeId?: NodeId,
-  clientHost?: Host,
-  clientPort?: Port,
+  clientHost?: string,
+  clientPort?: number,
   fs = require('fs'),
   logger = new Logger(processClientStatus.name),
 ): Promise<
   | {
       statusInfo: StatusStarting | StatusStopping | StatusDead;
       status: Status;
       nodeId: NodeId | undefined;
-      clientHost: Host | undefined;
-      clientPort: Port | undefined;
+      clientHost: string | undefined;
+      clientPort: number | undefined;
     }
   | {
       statusInfo: StatusLive;
       status: Status;
       nodeId: NodeId;
-      clientHost: Host;
-      clientPort: Port;
+      clientHost: string;
+      clientPort: number;
     }
   | {
       statusInfo: undefined;
       status: undefined;
       nodeId: NodeId;
-      clientHost: Host;
-      clientPort: Port;
+      clientHost: string;
+      clientPort: number;
     }
 > {
   if (nodeId != null && clientHost != null && clientPort != null) {

src/bin/utils/processors.ts

@@ -1,7 +1,6 @@
 import type { ClientRPCRequestParams, ClientRPCResponseResult } from '../types';
 import type { StatusResultMessage } from './types';
 import type PolykeyAgent from '../../PolykeyAgent';
-import type { Host, Port } from '../../network/types';
 import * as nodesUtils from '../../nodes/utils';
 import * as keysUtils from '../../keys/utils';
 import { UnaryHandler } from '../../rpc/handlers';
@@ -21,8 +20,8 @@ class AgentStatusHandler extends UnaryHandler<
       nodeIdEncoded: nodesUtils.encodeNodeId(pkAgent.keyRing.getNodeId()),
       clientHost: pkAgent.webSocketServerClient.getHost(),
       clientPort: pkAgent.webSocketServerClient.getPort(),
-      agentHost: pkAgent.quicSocket.host as unknown as Host,
-      agentPort: pkAgent.quicSocket.port as unknown as Port,
+      agentHost: pkAgent.quicSocket.host,
+      agentPort: pkAgent.quicSocket.port,
       publicKeyJwk: keysUtils.publicKeyToJWK(pkAgent.keyRing.keyPair.publicKey),
       certChainPEM: await pkAgent.certManager.getCertPEMsChainPEM(),
     };

src/client/handlers/agentStatus.ts

@@ -10,17 +10,16 @@ import type {
 } from '../../keys/types';
 import type { Notification } from '../../notifications/types';
 import type { CommitId, VaultAction, VaultName } from '../../vaults/types';
-import type { Host, Port } from '../../network/types';
 
 // Agent messages
 export type StatusResultMessage = {
   pid: number;
 } & NodeIdMessage &
   PublicKeyMessage & {
-    clientHost: Host;
-    clientPort: Port;
-    agentHost: Host;
-    agentPort: Port;
+    clientHost: string;
+    clientPort: number;
+    agentHost: string;
+    agentPort: number;
     certChainPEM: CertificatePEMChain;
   };
 

src/client/handlers/types.ts

@@ -91,12 +91,12 @@ const config = {
     },
     networkConfig: {
       // Config for the QUICSocket
-      agentHost: '127.0.0.1' as Host,
-      agentPort: 0 as Port,
+      agentHost: '127.0.0.1',
+      agentPort: 0,
       ipv6Only: false,
       // Config for the websocket server
-      clientHost: '127.0.0.1' as Host,
-      clientPort: 0 as Port,
+      clientHost: '127.0.0.1',
+      clientPort: 0,
       // Websocket server config
       maxReadableStreamBytes: 1_000_000_000, // About 1 GB
       connectionIdleTimeoutTime: 120, // 2 minutes

src/config.ts

@@ -4,12 +4,7 @@ import type { NodeId, QUICClientConfig } from './types';
 import type { Host, Hostname, Port } from '../network/types';
 import type { CertificatePEM } from '../keys/types';
 import type { ClientManifest } from '../rpc/types';
-import type {
-  Host as QUICHost,
-  Port as QUICPort,
-  QUICSocket,
-  ClientCrypto,
-} from '@matrixai/quic';
+import type { QUICSocket, ClientCrypto } from '@matrixai/quic';
 import type { ContextTimedInput } from '@matrixai/contexts/dist/types';
 import type { X509Certificate } from '@peculiar/x509';
 import Logger from '@matrixai/logger';
@@ -115,8 +110,8 @@ class NodeConnection<M extends ClientManifest> extends EventTarget {
     let validatedNodeId: NodeId | undefined;
     const quicClient = await QUICClient.createQUICClient(
       {
-        host: targetHost as unknown as QUICHost,
-        port: targetPort as unknown as QUICPort,
+        host: targetHost,
+        port: targetPort,
         socket: quicSocket,
         config: {
           verifyPeer: true,
@@ -161,8 +156,8 @@ class NodeConnection<M extends ClientManifest> extends EventTarget {
       nodeId,
       host: targetHost,
       port: targetPort,
-      localHost: connection.localHost as unknown as Host,
-      localPort: connection.localPort as unknown as Port,
+      localHost: connection.localHost as Host,
+      localPort: connection.localPort as Port,
       certChain,
       hostname: targetHostname,
       quicClient,

src/nodes/NodeConnection.ts

@@ -678,8 +678,8 @@ class NodeConnectionManager {
     const connectionMap = this.quicSocket.connectionMap;
     // Checking existing connections
     for (const [, connection] of connectionMap.serverConnections) {
-      const connectionHost = connection.remoteHost as unknown as Host;
-      const connectionPort = connection.remotePort as unknown as Port;
+      const connectionHost = connection.remoteHost;
+      const connectionPort = connection.remotePort;
       if (host === connectionHost && port === connectionPort) {
         // Connection exists, return early
         return;

src/nodes/NodeConnectionManager.ts

@@ -14,10 +14,10 @@ type StatusLive = {
   data: {
     pid: number;
     nodeId: NodeId;
-    clientHost: Host;
-    clientPort: Port;
-    agentHost: Host;
-    agentPort: Port;
+    clientHost: string;
+    clientPort: number;
+    agentHost: string;
+    agentPort: number;
     [key: string]: any;
   };
 };