kubernetes-fluent-client 3.0.4 → 4.0.0-rc-http2-watch

package/dist/fluent/watch.d.ts

@@ -41,6 +41,8 @@ export type WatchCfg = {
     relistIntervalSec?: number;
     /** Max amount of seconds to go without receiving an event before reconciliation starts. Defaults to 300 (5 minutes). */
     lastSeenLimitSeconds?: number;
+    /** Use http2 for the Watch */
+    useHTTP2?: boolean;
 };
 /** A wrapper around the Kubernetes watch API. */
 export declare class Watcher<T extends GenericClass> {

package/dist/fluent/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/fluent/watch.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAItC,OAAO,EAAE,YAAY,EAAwB,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAG3D,oBAAY,UAAU;IACpB,sCAAsC;IACtC,OAAO,YAAY;IACnB,2BAA2B;IAC3B,aAAa,kBAAkB;IAC/B,kDAAkD;IAClD,UAAU,eAAe;IACzB,0BAA0B;IAC1B,SAAS,cAAc;IACvB,8BAA8B;IAC9B,OAAO,YAAY;IACnB,sBAAsB;IACtB,KAAK,UAAU;IACf,mCAAmC;IACnC,IAAI,SAAS;IACb,wCAAwC;IACxC,oBAAoB,yBAAyB;IAC7C,qCAAqC;IACrC,iBAAiB,sBAAsB;IACvC,kCAAkC;IAClC,IAAI,SAAS;IACb,2BAA2B;IAC3B,UAAU,eAAe;IACzB,mBAAmB;IACnB,UAAU,eAAe;IACzB,qCAAqC;IACrC,wBAAwB,6BAA6B;IACrD,iCAAiC;IACjC,eAAe,oBAAoB;CACpC;AAED,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG;IACrB,+HAA+H;IAC/H,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wHAAwH;IACxH,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAKF,iDAAiD;AACjD,qBAAa,OAAO,CAAC,CAAC,SAAS,YAAY;;IAyBzC,YAAY,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAc9B;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,QAAa;IA0CzF;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAM9C,gGAAgG;IACzF,KAAK;IAOZ;;;;;OAKG;IACI,UAAU;IAWjB;;;;;;OAMG;IACH,IAAW,MAAM,IAAI,YAAY,CAEhC;CAiUF"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/fluent/watch.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAKtC,OAAO,EAAE,YAAY,EAAwB,MAAM,UAAU,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,WAAW,EAAc,MAAM,SAAS,CAAC;AAI3D,oBAAY,UAAU;IACpB,sCAAsC;IACtC,OAAO,YAAY;IACnB,2BAA2B;IAC3B,aAAa,kBAAkB;IAC/B,kDAAkD;IAClD,UAAU,eAAe;IACzB,0BAA0B;IAC1B,SAAS,cAAc;IACvB,8BAA8B;IAC9B,OAAO,YAAY;IACnB,sBAAsB;IACtB,KAAK,UAAU;IACf,mCAAmC;IACnC,IAAI,SAAS;IACb,wCAAwC;IACxC,oBAAoB,yBAAyB;IAC7C,qCAAqC;IACrC,iBAAiB,sBAAsB;IACvC,kCAAkC;IAClC,IAAI,SAAS;IACb,2BAA2B;IAC3B,UAAU,eAAe;IACzB,mBAAmB;IACnB,UAAU,eAAe;IACzB,qCAAqC;IACrC,wBAAwB,6BAA6B;IACrD,iCAAiC;IACjC,eAAe,oBAAoB;CACpC;AAED,4CAA4C;AAC5C,MAAM,MAAM,QAAQ,GAAG;IACrB,+HAA+H;IAC/H,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wHAAwH;IACxH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAKF,iDAAiD;AACjD,qBAAa,OAAO,CAAC,CAAC,SAAS,YAAY;;IA0BzC,YAAY,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC;IAgB9B;;;;;;;;;;;OAWG;gBACS,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,QAAQ,GAAE,QAAa;IA6CzF;;;;OAIG;IACU,KAAK,IAAI,OAAO,CAAC,eAAe,CAAC;IAU9C,gGAAgG;IACzF,KAAK;IAOZ;;;;;OAKG;IACI,UAAU;IAWjB;;;;;;OAMG;IACH,IAAW,MAAM,IAAI,YAAY,CAEhC;CA8bF"}

package/dist/fluent/watch.js

@@ -9,10 +9,13 @@ exports.Watcher = exports.WatchEvent = void 0;
 const byline_1 = __importDefault(require("byline"));
 const crypto_1 = require("crypto");
 const events_1 = require("events");
+const https_1 = __importDefault(require("https"));
+const http2_1 = __importDefault(require("http2"));
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const fetch_1 = require("../fetch");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
+const fs_1 = __importDefault(require("fs"));
 var WatchEvent;
 (function (WatchEvent) {
     /** Watch is connected successfully */
@@ -54,6 +57,7 @@ class Watcher {
     #callback;
     #watchCfg;
     #latestRelistWindow = "";
+    #useHTTP2 = false;
     // Track the last time data was received
     #lastSeenTime = NONE;
     #lastSeenLimit;
@@ -75,6 +79,8 @@ class Watcher {
     #resourceVersion;
     // Track the list of items in the cache
     #cache = new Map();
+    // Token Path
+    #TOKEN_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/token";
     /**
      * Setup a Kubernetes watcher for the specified model and filters. The callback function will be called for each event received.
      * The watch can be aborted by calling {@link Watcher.close} or by calling abort() on the AbortController returned by {@link Watcher.start}.
@@ -98,6 +104,8 @@ class Watcher {
         this.#lastSeenLimit = watchCfg.lastSeenLimitSeconds * 1000;
         // Set the latest relist interval to now
         this.#latestRelistWindow = new Date().toISOString();
+        // Set the latest relist interval to now
+        this.#useHTTP2 = watchCfg.useHTTP2 ?? false;
         // Add random jitter to the relist/resync intervals (up to 1 second)
         const jitter = Math.floor(Math.random() * 1000);
         // Check every relist interval for cache staleness
@@ -123,7 +131,12 @@ class Watcher {
      */
     async start() {
         this.#events.emit(WatchEvent.INIT_CACHE_MISS, this.#latestRelistWindow);
-        await this.#watch();
+        if (this.#useHTTP2) {
+            await this.#http2Watch();
+        }
+        else {
+            await this.#watch();
+        }
         return this.#abortController;
     }
     /** Close the watch. Also available on the AbortController returned by {@link Watcher.start}. */
@@ -158,6 +171,19 @@ class Watcher {
     get events() {
         return this.#events;
     }
+    /**
+     * Read the serviceAccount Token
+     *
+     * @returns token or null
+     */
+    async #getToken() {
+        try {
+            return (await fs_1.default.promises.readFile(this.#TOKEN_PATH, "utf8")).trim();
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Build the URL and request options for the watch.
      *
@@ -285,6 +311,32 @@ class Watcher {
             this.#events.emit(WatchEvent.DATA_ERROR, err);
         }
     };
+    // process a line from the chunk
+    #processLine = async (line, process) => {
+        try {
+            // Parse the event payload
+            const { object: payload, type: phase } = JSON.parse(line);
+            // Update the last seen time
+            this.#lastSeenTime = Date.now();
+            // If the watch is too old, remove the resourceVersion and reload the watch
+            if (phase === types_1.WatchPhase.Error && payload.code === 410) {
+                throw {
+                    name: "TooOld",
+                    message: this.#resourceVersion,
+                };
+            }
+            // Process the event payload, do not update the resource version as that is handled by the list operation
+            await process(payload, phase);
+        }
+        catch (err) {
+            if (err.name === "TooOld") {
+                // Reload the watch
+                void this.#errHandler(err);
+                return;
+            }
+            this.#events.emit(WatchEvent.DATA_ERROR, err);
+        }
+    };
     /**
      * Watch for changes to the resource.
      */
@@ -313,31 +365,7 @@ class Watcher {
                 this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
                 // Listen for events and call the callback function
                 this.#stream.on("data", async (line) => {
-                    try {
-                        // Parse the event payload
-                        const { object: payload, type: phase } = JSON.parse(line);
-                        // Update the last seen time
-                        this.#lastSeenTime = Date.now();
-                        // If the watch is too old, remove the resourceVersion and reload the watch
-                        if (phase === types_1.WatchPhase.Error && payload.code === 410) {
-                            throw {
-                                name: "TooOld",
-                                message: this.#resourceVersion,
-                            };
-                        }
-                        // Process the event payload, do not update the resource version as that is handled by the list operation
-                        await this.#process(payload, phase);
-                    }
-                    catch (err) {
-                        if (err.name === "TooOld") {
-                            // Prevent any body events from firing
-                            body.removeAllListeners();
-                            // Reload the watch
-                            void this.#errHandler(err);
-                            return;
-                        }
-                        this.#events.emit(WatchEvent.DATA_ERROR, err);
-                    }
+                    await this.#processLine(line, this.#process);
                 });
                 // Bind the body events
                 body.on("error", this.#errHandler);
@@ -354,6 +382,93 @@ class Watcher {
             void this.#errHandler(e);
         }
     };
+    /**
+     * Watch for changes to the resource.
+     */
+    #http2Watch = async () => {
+        try {
+            // Start with a list operation
+            await this.#list();
+            // Build the URL and request options
+            const { opts, url } = await this.#buildURL(true, this.#resourceVersion);
+            let agentOptions;
+            if (opts.agent && opts.agent instanceof https_1.default.Agent) {
+                agentOptions = {
+                    key: opts.agent.options.key,
+                    cert: opts.agent.options.cert,
+                    ca: opts.agent.options.ca,
+                    rejectUnauthorized: false,
+                };
+            }
+            // HTTP/2 client connection setup
+            const client = http2_1.default.connect(url.origin, {
+                ca: agentOptions?.ca,
+                cert: agentOptions?.cert,
+                key: agentOptions?.key,
+                rejectUnauthorized: agentOptions?.rejectUnauthorized,
+            });
+            // Set up headers for the HTTP/2 request
+            const token = await this.#getToken();
+            const headers = {
+                ":method": "GET",
+                ":path": url.pathname + url.search,
+                "content-type": "application/json",
+                "user-agent": "kubernetes-fluent-client",
+            };
+            if (token) {
+                headers["Authorization"] = `Bearer ${token}`;
+            }
+            // Make the HTTP/2 request
+            const req = client.request(headers);
+            req.setEncoding("utf8");
+            let buffer = "";
+            // Handle response data
+            req.on("response", headers => {
+                const statusCode = headers[":status"];
+                if (statusCode && statusCode >= 200 && statusCode < 300) {
+                    this.#pendingReconnect = false;
+                    this.#events.emit(WatchEvent.CONNECT, url.pathname);
+                    // Reset the retry count
+                    this.#resyncFailureCount = 0;
+                    this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
+                    req.on("data", async (chunk) => {
+                        try {
+                            buffer += chunk;
+                            const lines = buffer.split("\n");
+                            // Avoid  Watch event data_error received. Unexpected end of JSON input.
+                            buffer = lines.pop();
+                            for (const line of lines) {
+                                await this.#processLine(line, this.#process);
+                            }
+                        }
+                        catch (err) {
+                            void this.#errHandler(err);
+                        }
+                    });
+                    req.on("end", () => {
+                        this.#streamCleanup();
+                        client.close();
+                    });
+                    req.on("close", () => {
+                        this.#streamCleanup();
+                        client.close();
+                    });
+                    req.on("error", err => {
+                        void this.#errHandler(err);
+                        client.close();
+                    });
+                }
+                else {
+                    const statusMessage = headers[":status-text"] || "Unknown";
+                    throw new Error(`watch connect failed: ${statusCode} ${statusMessage}`);
+                }
+            });
+            req.end();
+        }
+        catch (e) {
+            void this.#errHandler(e);
+        }
+    };
     /** Clear the resync timer and schedule a new one. */
     #checkResync = () => {
         // Ignore if the last seen time is not set
@@ -379,7 +494,9 @@ class Watcher {
                     this.#pendingReconnect = true;
                     this.#events.emit(WatchEvent.RECONNECT, this.#resyncFailureCount);
                     this.#streamCleanup();
-                    void this.#watch();
+                    if (!this.#useHTTP2) {
+                        void this.#watch();
+                    }
                 }
             }
             else {
@@ -420,6 +537,9 @@ class Watcher {
             this.#stream.removeAllListeners();
             this.#stream.destroy();
         }
+        if (this.#useHTTP2) {
+            void this.#http2Watch();
+        }
     };
 }
 exports.Watcher = Watcher;

package/e2e/cli.e2e.test.ts

@@ -36,16 +36,20 @@ describe("End-to-End CLI tests with multiple test files", () => {
     const expectedDir = path.join(__dirname, `crds/${name}.default.expected`); // Expected default directory
     const expectedPostDir = path.join(__dirname, `crds/${name}.no.post.expected`); // Expected post-processing directory
 
-    console.log(`Running tests for ${name}`);
-    console.log(`Test file: ${mockYamlPath}`);
-    console.log(`Output directory: ${mockDir}`);
-    console.log(`Expected directory: ${expectedDir}`);
-    console.log(`Expected post-processing directory: ${expectedPostDir}`);
+    const testInfoMessage = `
+      Running tests for ${name}
+                               Test file: ${mockYamlPath}
+                        Output directory: ${mockDir}
+                      Expected directory: ${expectedDir}
+      Expected post-processing directory: ${expectedPostDir}
+    `;
+
+    console.log(testInfoMessage);
 
     beforeEach(() => {
       // Ensure the output directory is clean
       if (fs.existsSync(mockDir)) {
-        fs.rmdirSync(mockDir, { recursive: true });
+        fs.rmSync(mockDir, { recursive: true });
       }
 
       // Recreate the output directory
@@ -55,7 +59,7 @@ describe("End-to-End CLI tests with multiple test files", () => {
     afterEach(() => {
       // Cleanup the output directory after each test
       if (fs.existsSync(mockDir)) {
-        fs.rmdirSync(mockDir, { recursive: true });
+        fs.rmSync(mockDir, { recursive: true });
       }
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubernetes-fluent-client",
-  "version": "3.0.4",
+  "version": "4.0.0-rc-http2-watch",
   "description": "A @kubernetes/client-node fluent API wrapper that leverages K8s Server Side Apply.",
   "bin": "./dist/cli.js",
   "main": "dist/index.js",
@@ -53,9 +53,9 @@
     "@types/readable-stream": "4.0.15",
     "@types/urijs": "^1.19.25",
     "@types/yargs": "17.0.33",
-    "@typescript-eslint/eslint-plugin": "8.7.0",
-    "@typescript-eslint/parser": "8.7.0",
-    "eslint-plugin-jsdoc": "50.3.0",
+    "@typescript-eslint/eslint-plugin": "8.8.1",
+    "@typescript-eslint/parser": "8.8.1",
+    "eslint-plugin-jsdoc": "50.3.1",
     "jest": "29.7.0",
     "nock": "13.5.5",
     "prettier": "3.3.3",

package/src/fluent/watch.ts

@@ -4,12 +4,14 @@
 import byline from "byline";
 import { createHash } from "crypto";
 import { EventEmitter } from "events";
+import https from "https";
+import http2 from "http2";
 import fetch from "node-fetch";
-
 import { fetch as wrappedFetch } from "../fetch";
 import { GenericClass, KubernetesListObject } from "../types";
 import { Filters, WatchAction, WatchPhase } from "./types";
 import { k8sCfg, pathBuilder } from "./utils";
+import fs from "fs";
 
 export enum WatchEvent {
   /** Watch is connected successfully */
@@ -52,6 +54,8 @@ export type WatchCfg = {
   relistIntervalSec?: number;
   /** Max amount of seconds to go without receiving an event before reconciliation starts. Defaults to 300 (5 minutes). */
   lastSeenLimitSeconds?: number;
+  /** Use http2 for the Watch */
+  useHTTP2?: boolean;
 };
 
 const NONE = 50;
@@ -65,6 +69,7 @@ export class Watcher<T extends GenericClass> {
   #callback: WatchAction<T>;
   #watchCfg: WatchCfg;
   #latestRelistWindow: string = "";
+  #useHTTP2: boolean = false;
 
   // Track the last time data was received
   #lastSeenTime = NONE;
@@ -97,6 +102,8 @@ export class Watcher<T extends GenericClass> {
   // Track the list of items in the cache
   #cache = new Map<string, InstanceType<T>>();
 
+  // Token Path
+  #TOKEN_PATH = "/var/run/secrets/kubernetes.io/serviceaccount/token";
   /**
    * Setup a Kubernetes watcher for the specified model and filters. The callback function will be called for each event received.
    * The watch can be aborted by calling {@link Watcher.close} or by calling abort() on the AbortController returned by {@link Watcher.start}.
@@ -125,6 +132,9 @@ export class Watcher<T extends GenericClass> {
     // Set the latest relist interval to now
     this.#latestRelistWindow = new Date().toISOString();
 
+    // Set the latest relist interval to now
+    this.#useHTTP2 = watchCfg.useHTTP2 ?? false;
+
     // Add random jitter to the relist/resync intervals (up to 1 second)
     const jitter = Math.floor(Math.random() * 1000);
 
@@ -158,7 +168,11 @@ export class Watcher<T extends GenericClass> {
    */
   public async start(): Promise<AbortController> {
     this.#events.emit(WatchEvent.INIT_CACHE_MISS, this.#latestRelistWindow);
-    await this.#watch();
+    if (this.#useHTTP2) {
+      await this.#http2Watch();
+    } else {
+      await this.#watch();
+    }
     return this.#abortController;
   }
 
@@ -198,6 +212,19 @@ export class Watcher<T extends GenericClass> {
     return this.#events;
   }
 
+  /**
+   * Read the serviceAccount Token
+   *
+   * @returns token or null
+   */
+  async #getToken() {
+    try {
+      return (await fs.promises.readFile(this.#TOKEN_PATH, "utf8")).trim();
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * Build the URL and request options for the watch.
    *
@@ -351,6 +378,42 @@ export class Watcher<T extends GenericClass> {
     }
   };
 
+  // process a line from the chunk
+  #processLine = async (
+    line: string,
+    process: (payload: InstanceType<T>, phase: WatchPhase) => Promise<void>,
+  ) => {
+    try {
+      // Parse the event payload
+      const { object: payload, type: phase } = JSON.parse(line) as {
+        type: WatchPhase;
+        object: InstanceType<T>;
+      };
+
+      // Update the last seen time
+      this.#lastSeenTime = Date.now();
+
+      // If the watch is too old, remove the resourceVersion and reload the watch
+      if (phase === WatchPhase.Error && payload.code === 410) {
+        throw {
+          name: "TooOld",
+          message: this.#resourceVersion!,
+        };
+      }
+
+      // Process the event payload, do not update the resource version as that is handled by the list operation
+      await process(payload, phase);
+    } catch (err) {
+      if (err.name === "TooOld") {
+        // Reload the watch
+        void this.#errHandler(err);
+        return;
+      }
+
+      this.#events.emit(WatchEvent.DATA_ERROR, err);
+    }
+  };
+
   /**
    * Watch for changes to the resource.
    */
@@ -388,38 +451,7 @@ export class Watcher<T extends GenericClass> {
 
         // Listen for events and call the callback function
         this.#stream.on("data", async line => {
-          try {
-            // Parse the event payload
-            const { object: payload, type: phase } = JSON.parse(line) as {
-              type: WatchPhase;
-              object: InstanceType<T>;
-            };
-
-            // Update the last seen time
-            this.#lastSeenTime = Date.now();
-
-            // If the watch is too old, remove the resourceVersion and reload the watch
-            if (phase === WatchPhase.Error && payload.code === 410) {
-              throw {
-                name: "TooOld",
-                message: this.#resourceVersion!,
-              };
-            }
-
-            // Process the event payload, do not update the resource version as that is handled by the list operation
-            await this.#process(payload, phase);
-          } catch (err) {
-            if (err.name === "TooOld") {
-              // Prevent any body events from firing
-              body.removeAllListeners();
-
-              // Reload the watch
-              void this.#errHandler(err);
-              return;
-            }
-
-            this.#events.emit(WatchEvent.DATA_ERROR, err);
-          }
+          await this.#processLine(line, this.#process);
         });
 
         // Bind the body events
@@ -437,6 +469,108 @@ export class Watcher<T extends GenericClass> {
     }
   };
 
+  /**
+   * Watch for changes to the resource.
+   */
+  #http2Watch = async () => {
+    try {
+      // Start with a list operation
+      await this.#list();
+
+      // Build the URL and request options
+      const { opts, url } = await this.#buildURL(true, this.#resourceVersion);
+      let agentOptions;
+
+      if (opts.agent && opts.agent instanceof https.Agent) {
+        agentOptions = {
+          key: opts.agent.options.key,
+          cert: opts.agent.options.cert,
+          ca: opts.agent.options.ca,
+          rejectUnauthorized: false,
+        };
+      }
+
+      // HTTP/2 client connection setup
+      const client = http2.connect(url.origin, {
+        ca: agentOptions?.ca,
+        cert: agentOptions?.cert,
+        key: agentOptions?.key,
+        rejectUnauthorized: agentOptions?.rejectUnauthorized,
+      });
+
+      // Set up headers for the HTTP/2 request
+      const token = await this.#getToken();
+      const headers: Record<string, string> = {
+        ":method": "GET",
+        ":path": url.pathname + url.search,
+        "content-type": "application/json",
+        "user-agent": "kubernetes-fluent-client",
+      };
+
+      if (token) {
+        headers["Authorization"] = `Bearer ${token}`;
+      }
+
+      // Make the HTTP/2 request
+      const req = client.request(headers);
+
+      req.setEncoding("utf8");
+
+      let buffer = "";
+
+      // Handle response data
+      req.on("response", headers => {
+        const statusCode = headers[":status"];
+
+        if (statusCode && statusCode >= 200 && statusCode < 300) {
+          this.#pendingReconnect = false;
+          this.#events.emit(WatchEvent.CONNECT, url.pathname);
+
+          // Reset the retry count
+          this.#resyncFailureCount = 0;
+          this.#events.emit(WatchEvent.INC_RESYNC_FAILURE_COUNT, this.#resyncFailureCount);
+
+          req.on("data", async chunk => {
+            try {
+              buffer += chunk;
+              const lines = buffer.split("\n");
+              // Avoid  Watch event data_error received. Unexpected end of JSON input.
+              buffer = lines.pop()!;
+
+              for (const line of lines) {
+                await this.#processLine(line, this.#process);
+              }
+            } catch (err) {
+              void this.#errHandler(err);
+            }
+          });
+
+          req.on("end", () => {
+            this.#streamCleanup();
+            client.close();
+          });
+
+          req.on("close", () => {
+            this.#streamCleanup();
+            client.close();
+          });
+
+          req.on("error", err => {
+            void this.#errHandler(err);
+            client.close();
+          });
+        } else {
+          const statusMessage = headers[":status-text"] || "Unknown";
+          throw new Error(`watch connect failed: ${statusCode} ${statusMessage}`);
+        }
+      });
+
+      req.end();
+    } catch (e) {
+      void this.#errHandler(e);
+    }
+  };
+
   /** Clear the resync timer and schedule a new one. */
   #checkResync = () => {
     // Ignore if the last seen time is not set
@@ -468,7 +602,9 @@ export class Watcher<T extends GenericClass> {
           this.#events.emit(WatchEvent.RECONNECT, this.#resyncFailureCount);
           this.#streamCleanup();
 
-          void this.#watch();
+          if (!this.#useHTTP2) {
+            void this.#watch();
+          }
         }
       } else {
         // Otherwise, call the finally function if it exists
@@ -516,5 +652,8 @@ export class Watcher<T extends GenericClass> {
       this.#stream.removeAllListeners();
       this.#stream.destroy();
     }
+    if (this.#useHTTP2) {
+      void this.#http2Watch();
+    }
   };
 }